docstring_tokens
list | code_tokens
list |
|---|---|
[
"returns",
"the",
"current",
"index",
"capacity"
] |
[
"public",
"short",
"get",
"capacity",
"(",
")",
"{",
"return",
"capacity",
";",
"}"
] |
[
"get",
"the",
"boolean",
"value",
"associated",
"with",
"a",
"key"
] |
[
"public",
"boolean",
"get",
"boolean",
"(",
"string",
"key",
")",
"throws",
"j",
"s",
"o",
"n",
"exception",
"{",
"object",
"o",
"=",
"get",
"(",
"key",
")",
";",
"if",
"(",
"o",
"equals",
"(",
"boolean",
"false",
")",
"|",
"|",
"(",
"o",
"instanceof",
"string",
"&",
"&",
"(",
"(",
"string",
")",
"o",
")",
"equals",
"ignore",
"case",
"(",
"\"",
"false",
"\"",
")",
")",
")",
"{",
"return",
"false",
";",
"}",
"else",
"if",
"(",
"o",
"equals",
"(",
"boolean",
"true",
")",
"|",
"|",
"(",
"o",
"instanceof",
"string",
"&",
"&",
"(",
"(",
"string",
")",
"o",
")",
"equals",
"ignore",
"case",
"(",
"\"",
"true",
"\"",
")",
")",
")",
"{",
"return",
"true",
";",
"}",
"throw",
"new",
"j",
"s",
"o",
"n",
"exception",
"(",
"\"",
"j",
"s",
"o",
"n",
"object",
"[",
"\"",
"+",
"quote",
"(",
"key",
")",
"+",
"\"",
"]",
"is",
"not",
"a",
"boolean",
"\"",
")",
";",
"}"
] |
[
"the",
"name",
"of",
"this",
"element",
"<",
"code",
">",
"optional",
"string",
"name",
"=",
"3",
";",
"<",
"code",
">"
] |
[
"public",
"java",
"lang",
"string",
"get",
"name",
"(",
")",
"{",
"return",
"instance",
"get",
"name",
"(",
")",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}",
"the",
"{",
"@",
"code",
"abstract",
"list",
"tester",
"}",
"implementation",
"overrides",
"{",
"@",
"link",
"abstract",
"collection",
"tester",
"#",
"expect",
"contents",
"(",
"collection",
")",
"}",
"to",
"verify",
"that",
"the",
"order",
"of",
"the",
"elements",
"in",
"the",
"list",
"under",
"test",
"matches",
"what",
"is",
"expected"
] |
[
"protected",
"void",
"expect",
"contents",
"(",
"collection",
"<",
"e",
">",
"expected",
"collection",
")",
"{",
"list",
"<",
"e",
">",
"expected",
"list",
"=",
"helpers",
"copy",
"to",
"list",
"(",
"expected",
"collection",
")",
";",
"/",
"/",
"avoid",
"expect",
"equals",
"(",
")",
"here",
"to",
"delay",
"reason",
"manufacture",
"until",
"necessary",
"if",
"(",
"get",
"list",
"(",
")",
"size",
"(",
")",
"!",
"=",
"expected",
"list",
"size",
"(",
")",
")",
"{",
"fail",
"(",
"\"",
"size",
"mismatch",
":",
"\"",
"+",
"report",
"context",
"(",
"expected",
"list",
")",
")",
";",
"}",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"expected",
"list",
"size",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"e",
"expected",
"=",
"expected",
"list",
"get",
"(",
"i",
")",
";",
"e",
"actual",
"=",
"get",
"list",
"(",
")",
"get",
"(",
"i",
")",
";",
"if",
"(",
"expected",
"!",
"=",
"actual",
"&",
"&",
"(",
"expected",
"=",
"=",
"null",
"|",
"|",
"!",
"expected",
"equals",
"(",
"actual",
")",
")",
")",
"{",
"fail",
"(",
"\"",
"mismatch",
"at",
"index",
"\"",
"+",
"i",
"+",
"\"",
":",
"\"",
"+",
"report",
"context",
"(",
"expected",
"list",
")",
")",
";",
"}",
"}",
"}"
] |
[
"gets",
"property",
"double",
"value"
] |
[
"public",
"double",
"get",
"property",
"double",
"value",
"(",
"final",
"registered",
"service",
"service",
")",
"{",
"if",
"(",
"is",
"assigned",
"to",
"(",
"service",
")",
")",
"{",
"val",
"prop",
"=",
"get",
"property",
"value",
"(",
"service",
")",
";",
"if",
"(",
"prop",
"!",
"=",
"null",
")",
"{",
"return",
"double",
"parse",
"double",
"(",
"prop",
"get",
"value",
"(",
")",
")",
";",
"}",
"}",
"return",
"double",
"na",
"n",
";",
"}"
] |
[
"allows",
"the",
"parameter",
"to",
"accept",
"a",
"{",
"@",
"code",
"null",
"}",
"value"
] |
[
"public",
"parameter",
"<",
"t",
">",
"accepts",
"null",
"(",
")",
"{",
"this",
"accepts",
"null",
"=",
"true",
";",
"return",
"this",
";",
"}"
] |
[
"static",
"utility",
"to",
"parse",
"a",
"field",
"of",
"type",
"short",
"from",
"a",
"byte",
"sequence",
"that",
"represents",
"text",
"characters",
"(",
"such",
"as",
"when",
"read",
"from",
"a",
"file",
"stream",
")"
] |
[
"public",
"static",
"final",
"short",
"parse",
"field",
"(",
"byte",
"[",
"]",
"bytes",
",",
"int",
"start",
"pos",
",",
"int",
"length",
",",
"char",
"delimiter",
")",
"{",
"long",
"val",
"=",
"0",
";",
"boolean",
"neg",
"=",
"false",
";",
"if",
"(",
"bytes",
"[",
"start",
"pos",
"]",
"=",
"=",
"delimiter",
")",
"{",
"throw",
"new",
"number",
"format",
"exception",
"(",
"\"",
"empty",
"field",
"\"",
")",
";",
"}",
"if",
"(",
"bytes",
"[",
"start",
"pos",
"]",
"=",
"=",
"'",
"-",
"'",
")",
"{",
"neg",
"=",
"true",
";",
"start",
"pos",
"+",
"+",
";",
"length",
"-",
"-",
";",
"if",
"(",
"length",
"=",
"=",
"0",
"|",
"|",
"bytes",
"[",
"start",
"pos",
"]",
"=",
"=",
"delimiter",
")",
"{",
"throw",
"new",
"number",
"format",
"exception",
"(",
"\"",
"orphaned",
"minus",
"sign",
"\"",
")",
";",
"}",
"}",
"for",
"(",
";",
"length",
">",
"0",
";",
"start",
"pos",
"+",
"+",
",",
"length",
"-",
"-",
")",
"{",
"if",
"(",
"bytes",
"[",
"start",
"pos",
"]",
"=",
"=",
"delimiter",
")",
"{",
"return",
"(",
"short",
")",
"(",
"neg",
"?",
"-",
"val",
":",
"val",
")",
";",
"}",
"if",
"(",
"bytes",
"[",
"start",
"pos",
"]",
"<",
"48",
"|",
"|",
"bytes",
"[",
"start",
"pos",
"]",
">",
"57",
")",
"{",
"throw",
"new",
"number",
"format",
"exception",
"(",
"\"",
"invalid",
"character",
"\"",
")",
";",
"}",
"val",
"*",
"=",
"10",
";",
"val",
"+",
"=",
"bytes",
"[",
"start",
"pos",
"]",
"-",
"48",
";",
"if",
"(",
"val",
">",
"overflow",
"bound",
"&",
"&",
"(",
"!",
"neg",
"|",
"|",
"val",
">",
"underflow",
"bound",
")",
")",
"{",
"throw",
"new",
"number",
"format",
"exception",
"(",
"\"",
"value",
"overflow",
"/",
"underflow",
"\"",
")",
";",
"}",
"}",
"return",
"(",
"short",
")",
"(",
"neg",
"?",
"-",
"val",
":",
"val",
")",
";",
"}"
] |
[
"run",
"a",
"located",
"file",
"status",
"fetcher",
"against",
"the",
"directory",
"tree"
] |
[
"public",
"void",
"check",
"located",
"file",
"status",
"four",
"threads",
"(",
")",
"throws",
"throwable",
"{",
"/",
"/",
"four",
"threads",
"and",
"the",
"text",
"filter",
"int",
"threads",
"=",
"4",
";",
"describe",
"(",
"\"",
"located",
"file",
"status",
"fetcher",
"with",
"%",
"d",
"\"",
",",
"threads",
")",
";",
"role",
"config",
"set",
"int",
"(",
"list",
"status",
"num",
"threads",
",",
"threads",
")",
";",
"located",
"file",
"status",
"fetcher",
"fetcher",
"=",
"new",
"located",
"file",
"status",
"fetcher",
"(",
"role",
"config",
",",
"new",
"path",
"[",
"]",
"{",
"no",
"read",
"wildcard",
"}",
",",
"true",
",",
"everything",
",",
"true",
")",
";",
"assertions",
"assert",
"that",
"(",
"fetcher",
"get",
"file",
"statuses",
"(",
")",
")",
"described",
"as",
"(",
"\"",
"result",
"of",
"located",
"scan",
"\"",
")",
"is",
"not",
"null",
"(",
")",
"flat",
"extracting",
"(",
"file",
"status",
":",
":",
"get",
"path",
")",
"contains",
"exactly",
"in",
"any",
"order",
"(",
"subdir",
"file",
",",
"subdir",
"2",
"file",
"1",
")",
";",
"}"
] |
[
"takes",
"all",
"vertices",
"in",
"the",
"given",
"execution",
"graph",
"and",
"switches",
"their",
"current",
"execution",
"to",
"running"
] |
[
"public",
"static",
"void",
"switch",
"all",
"vertices",
"to",
"running",
"(",
"execution",
"graph",
"eg",
")",
"{",
"for",
"(",
"execution",
"vertex",
"vertex",
":",
"eg",
"get",
"all",
"execution",
"vertices",
"(",
")",
")",
"{",
"vertex",
"get",
"current",
"execution",
"attempt",
"(",
")",
"switch",
"to",
"running",
"(",
")",
";",
"}",
"}"
] |
[
"sets",
"the",
"value"
] |
[
"void",
"set",
"(",
"t",
"value",
")",
";"
] |
[
"returns",
"the",
"label",
"corresponding",
"to",
"the",
"given",
"bytecode",
"offset",
"the",
"default",
"implementation",
"of",
"this",
"method",
"creates",
"a",
"label",
"for",
"the",
"given",
"offset",
"if",
"it",
"has",
"not",
"been",
"already",
"created"
] |
[
"protected",
"label",
"read",
"label",
"(",
"final",
"int",
"bytecode",
"offset",
",",
"final",
"label",
"[",
"]",
"labels",
")",
"{",
"/",
"/",
"spring",
"patch",
":",
"leniently",
"handle",
"offset",
"mismatch",
"if",
"(",
"bytecode",
"offset",
">",
"=",
"labels",
"length",
")",
"{",
"return",
"new",
"label",
"(",
")",
";",
"}",
"/",
"/",
"end",
"of",
"patch",
"if",
"(",
"labels",
"[",
"bytecode",
"offset",
"]",
"=",
"=",
"null",
")",
"{",
"labels",
"[",
"bytecode",
"offset",
"]",
"=",
"new",
"label",
"(",
")",
";",
"}",
"return",
"labels",
"[",
"bytecode",
"offset",
"]",
";",
"}"
] |
[
"returns",
"true",
"if",
"the",
"input",
"string",
"represents",
"a",
"full",
"byte",
"of",
"information"
] |
[
"public",
"static",
"boolean",
"is",
"full",
"hex",
"byte",
"(",
"string",
"input",
")",
"{",
"string",
"text",
"=",
"input",
"replace",
"all",
"(",
"\"",
"\\",
"\\",
"s",
"\"",
",",
"\"",
"\"",
")",
";",
"return",
"text",
"length",
"(",
")",
"%",
"2",
"=",
"=",
"0",
";",
"}"
] |
[
"returns",
"the",
"digest",
"of",
"the",
"{",
"@",
"link",
"table",
"source",
"}",
"instance"
] |
[
"protected",
"list",
"<",
"string",
">",
"explain",
"source",
"as",
"string",
"(",
"table",
"source",
"<",
"?",
">",
"ts",
")",
"{",
"string",
"ts",
"digest",
"=",
"ts",
"explain",
"source",
"(",
")",
";",
"if",
"(",
"!",
"strings",
"is",
"null",
"or",
"empty",
"(",
"ts",
"digest",
")",
")",
"{",
"return",
"immutable",
"list",
"<",
"string",
">",
"builder",
"(",
")",
"add",
"all",
"(",
"util",
"skip",
"last",
"(",
"names",
")",
")",
"add",
"(",
"string",
"format",
"(",
"\"",
"%",
"s",
",",
"source",
":",
"[",
"%",
"s",
"]",
"\"",
",",
"util",
"last",
"(",
"names",
")",
",",
"ts",
"digest",
")",
")",
"build",
"(",
")",
";",
"}",
"else",
"{",
"return",
"names",
";",
"}",
"}"
] |
[
"assert",
"the",
"given",
"model",
"attribute",
"field",
"(",
"s",
")",
"have",
"errors"
] |
[
"public",
"result",
"matcher",
"attribute",
"has",
"field",
"errors",
"(",
"string",
"name",
",",
"string",
"field",
"names",
")",
"{",
"return",
"mvc",
"result",
"-",
">",
"{",
"model",
"and",
"view",
"mav",
"=",
"get",
"model",
"and",
"view",
"(",
"mvc",
"result",
")",
";",
"binding",
"result",
"result",
"=",
"get",
"binding",
"result",
"(",
"mav",
",",
"name",
")",
";",
"assert",
"true",
"(",
"\"",
"no",
"errors",
"for",
"attribute",
"'",
"\"",
"+",
"name",
"+",
"\"",
"'",
"\"",
",",
"result",
"has",
"errors",
"(",
")",
")",
";",
"for",
"(",
"string",
"field",
"name",
":",
"field",
"names",
")",
"{",
"boolean",
"has",
"field",
"errors",
"=",
"result",
"has",
"field",
"errors",
"(",
"field",
"name",
")",
";",
"assert",
"true",
"(",
"\"",
"no",
"errors",
"for",
"field",
"'",
"\"",
"+",
"field",
"name",
"+",
"\"",
"'",
"of",
"attribute",
"'",
"\"",
"+",
"name",
"+",
"\"",
"'",
"\"",
",",
"has",
"field",
"errors",
")",
";",
"}",
"}",
";",
"}"
] |
[
"increment",
"usage",
"with",
"quota",
"limit"
] |
[
"public",
"boolean",
"increment",
"usage",
"with",
"quota",
"limit",
"(",
"group",
"capacity",
"group",
"capacity",
")",
"{",
"string",
"sql",
"=",
"\"",
"update",
"group",
"capacity",
"set",
"`",
"usage",
"`",
"=",
"`",
"usage",
"`",
"+",
"1",
",",
"gmt",
"modified",
"=",
"?",
"where",
"group",
"id",
"=",
"?",
"and",
"`",
"usage",
"`",
"<",
"\"",
"+",
"\"",
"quota",
"and",
"quota",
"!",
"=",
"0",
"\"",
";",
"try",
"{",
"return",
"jdbc",
"template",
"update",
"(",
"sql",
",",
"group",
"capacity",
"get",
"gmt",
"modified",
"(",
")",
",",
"group",
"capacity",
"get",
"group",
"(",
")",
")",
"=",
"=",
"1",
";",
"}",
"catch",
"(",
"cannot",
"get",
"jdbc",
"connection",
"exception",
"e",
")",
"{",
"fatal",
"log",
"error",
"(",
"\"",
"[",
"db",
"-",
"error",
"]",
"\"",
",",
"e",
")",
";",
"throw",
"e",
";",
"}",
"}"
] |
[
"check",
"if",
"we",
"have",
"room",
"for",
"a",
"new",
"record",
"containing",
"the",
"given",
"keyvalue",
"pair",
"if",
"no",
"records",
"have",
"been",
"appended",
",",
"then",
"this",
"returns",
"true"
] |
[
"public",
"boolean",
"has",
"room",
"for",
"(",
"long",
"timestamp",
",",
"byte",
"[",
"]",
"key",
",",
"byte",
"[",
"]",
"value",
",",
"header",
"[",
"]",
"headers",
")",
"{",
"return",
"has",
"room",
"for",
"(",
"timestamp",
",",
"wrap",
"nullable",
"(",
"key",
")",
",",
"wrap",
"nullable",
"(",
"value",
")",
",",
"headers",
")",
";",
"}"
] |
[
"updates",
"a",
"pet",
"in",
"the",
"store",
"with",
"form",
"data"
] |
[
"public",
"void",
"update",
"pet",
"with",
"form",
"test",
"(",
"test",
"context",
"test",
"context",
")",
"{",
"async",
"async",
"=",
"test",
"context",
"async",
"(",
")",
";",
"long",
"pet",
"id",
"=",
"null",
";",
"string",
"name",
"=",
"null",
";",
"string",
"status",
"=",
"null",
";",
"api",
"update",
"pet",
"with",
"form",
"(",
"pet",
"id",
",",
"name",
",",
"status",
",",
"result",
"-",
">",
"{",
"/",
"/",
"todo",
":",
"test",
"validations",
"async",
"complete",
"(",
")",
";",
"}",
")",
";",
"}"
] |
[
"get",
"property",
"class"
] |
[
"public",
"string",
"get",
"property",
"class",
"(",
")",
"{",
"return",
"property",
"class",
";",
"}"
] |
[
"returns",
"an",
"{",
"@",
"link",
"org",
"elasticsearch",
"index",
"engine",
"engine",
"warmer",
"}",
"used",
"to",
"warm",
"new",
"searchers",
"before",
"they",
"are",
"used",
"for",
"searching"
] |
[
"public",
"engine",
"warmer",
"get",
"warmer",
"(",
")",
"{",
"return",
"warmer",
";",
"}"
] |
[
"sets",
"the",
"color",
"used",
"to",
"tint",
"this",
"sprite",
"default",
"is",
"{",
"@",
"link",
"color",
"#",
"white",
"}"
] |
[
"public",
"void",
"set",
"color",
"(",
"color",
"tint",
")",
"{",
"color",
"set",
"(",
"tint",
")",
";",
"float",
"color",
"=",
"tint",
"to",
"float",
"bits",
"(",
")",
";",
"float",
"[",
"]",
"vertices",
"=",
"this",
"vertices",
";",
"vertices",
"[",
"c1",
"]",
"=",
"color",
";",
"vertices",
"[",
"c2",
"]",
"=",
"color",
";",
"vertices",
"[",
"c3",
"]",
"=",
"color",
";",
"vertices",
"[",
"c4",
"]",
"=",
"color",
";",
"}"
] |
[
"get",
"ship",
"date"
] |
[
"public",
"date",
"get",
"ship",
"date",
"(",
")",
"{",
"return",
"ship",
"date",
";",
"}"
] |
[
"set",
"the",
"entity",
"tag",
"of",
"the",
"body",
",",
"as",
"specified",
"by",
"the",
"{",
"@",
"code",
"e",
"tag",
"}",
"header"
] |
[
"b",
"e",
"tag",
"(",
"string",
"e",
"tag",
")",
";"
] |
[
"returns",
"the",
"segment",
"that",
"should",
"be",
"used",
"for",
"a",
"key",
"with",
"the",
"given",
"hash"
] |
[
"segment",
"<",
"k",
",",
"v",
",",
"e",
",",
"s",
">",
"segment",
"for",
"(",
"int",
"hash",
")",
"{",
"/",
"/",
"todo",
"(",
"fry",
")",
":",
"lazily",
"create",
"segments",
"?",
"return",
"segments",
"[",
"(",
"hash",
">",
">",
">",
"segment",
"shift",
")",
"&",
"segment",
"mask",
"]",
";",
"}"
] |
[
"returns",
"the",
"mean",
"rate",
"at",
"which",
"video",
"frames",
"are",
"dropped",
",",
"in",
"dropped",
"frames",
"per",
"play",
"time",
"second",
",",
"or",
"{",
"@",
"code",
"0",
"0",
"}",
"if",
"no",
"time",
"was",
"spent",
"playing"
] |
[
"public",
"float",
"get",
"dropped",
"frames",
"rate",
"(",
")",
"{",
"long",
"play",
"time",
"ms",
"=",
"get",
"total",
"play",
"time",
"ms",
"(",
")",
";",
"return",
"play",
"time",
"ms",
"=",
"=",
"0",
"?",
"0f",
":",
"1",
"0",
"0",
"0f",
"*",
"total",
"dropped",
"frames",
"/",
"play",
"time",
"ms",
";",
"}"
] |
[
"play",
"sound",
"effect",
"for",
"the",
"superpower"
] |
[
"protected",
"void",
"play",
"sound",
"(",
"string",
"sound",
"name",
",",
"int",
"volumn",
")",
"{",
"logger",
"info",
"(",
"\"",
"play",
"\"",
"+",
"sound",
"name",
"+",
"\"",
"with",
"volumn",
"\"",
"+",
"volumn",
")",
";",
"}"
] |
[
"updates",
"the",
"{",
"@",
"link",
"texture",
"atlas",
"}",
",",
"adding",
"any",
"new",
"{",
"@",
"link",
"pixmap",
"}",
"instances",
"packed",
"since",
"the",
"last",
"call",
"to",
"this",
"method",
"this",
"can",
"be",
"used",
"to",
"insert",
"pixmap",
"instances",
"on",
"a",
"separate",
"thread",
"via",
"{",
"@",
"link",
"#",
"pack",
"(",
"string",
",",
"pixmap",
")",
"}",
"and",
"update",
"the",
"texture",
"atlas",
"on",
"the",
"rendering",
"thread",
"this",
"method",
"must",
"be",
"called",
"on",
"the",
"rendering",
"thread",
"after",
"calling",
"this",
"method",
",",
"disposing",
"the",
"packer",
"will",
"no",
"longer",
"dispose",
"the",
"page",
"pixmaps",
"has",
"use",
"indexes",
"on",
"by",
"default",
"so",
"as",
"to",
"keep",
"backwards",
"compatibility"
] |
[
"public",
"synchronized",
"void",
"update",
"texture",
"atlas",
"(",
"texture",
"atlas",
"atlas",
",",
"texture",
"filter",
"min",
"filter",
",",
"texture",
"filter",
"mag",
"filter",
",",
"boolean",
"use",
"mip",
"maps",
")",
"{",
"update",
"texture",
"atlas",
"(",
"atlas",
",",
"min",
"filter",
",",
"mag",
"filter",
",",
"use",
"mip",
"maps",
",",
"true",
")",
";",
"}"
] |
[
"waits",
"for",
"the",
"guard",
"to",
"be",
"satisfied",
"waits",
"at",
"most",
"the",
"given",
"time",
"may",
"be",
"called",
"only",
"by",
"a",
"thread",
"currently",
"occupying",
"this",
"monitor"
] |
[
"public",
"boolean",
"wait",
"for",
"uninterruptibly",
"(",
"guard",
"guard",
",",
"long",
"time",
",",
"time",
"unit",
"unit",
")",
"{",
"final",
"long",
"timeout",
"nanos",
"=",
"to",
"safe",
"nanos",
"(",
"time",
",",
"unit",
")",
";",
"if",
"(",
"!",
"(",
"(",
"guard",
"monitor",
"=",
"=",
"this",
")",
"&",
"lock",
"is",
"held",
"by",
"current",
"thread",
"(",
")",
")",
")",
"{",
"throw",
"new",
"illegal",
"monitor",
"state",
"exception",
"(",
")",
";",
"}",
"if",
"(",
"guard",
"is",
"satisfied",
"(",
")",
")",
"{",
"return",
"true",
";",
"}",
"boolean",
"signal",
"before",
"waiting",
"=",
"true",
";",
"final",
"long",
"start",
"time",
"=",
"init",
"nano",
"time",
"(",
"timeout",
"nanos",
")",
";",
"boolean",
"interrupted",
"=",
"thread",
"interrupted",
"(",
")",
";",
"try",
"{",
"for",
"(",
"long",
"remaining",
"nanos",
"=",
"timeout",
"nanos",
";",
";",
")",
"{",
"try",
"{",
"return",
"await",
"nanos",
"(",
"guard",
",",
"remaining",
"nanos",
",",
"signal",
"before",
"waiting",
")",
";",
"}",
"catch",
"(",
"interrupted",
"exception",
"interrupt",
")",
"{",
"interrupted",
"=",
"true",
";",
"if",
"(",
"guard",
"is",
"satisfied",
"(",
")",
")",
"{",
"return",
"true",
";",
"}",
"signal",
"before",
"waiting",
"=",
"false",
";",
"remaining",
"nanos",
"=",
"remaining",
"nanos",
"(",
"start",
"time",
",",
"timeout",
"nanos",
")",
";",
"}",
"}",
"}",
"finally",
"{",
"if",
"(",
"interrupted",
")",
"{",
"thread",
"current",
"thread",
"(",
")",
"interrupt",
"(",
")",
";",
"}",
"}",
"}"
] |
[
"set",
"the",
"connection",
"to",
"be",
"secure",
",",
"using",
"the",
"specified",
"keystore",
"and",
"truststore",
"this",
"has",
"to",
"be",
"called",
"before",
"any",
"route",
"mapping",
"is",
"done",
"you",
"have",
"to",
"supply",
"a",
"keystore",
"file",
",",
"truststore",
"file",
"is",
"optional",
"(",
"keystore",
"will",
"be",
"reused",
")",
"this",
"method",
"is",
"only",
"relevant",
"when",
"using",
"embedded",
"jetty",
"servers",
"it",
"should",
"not",
"be",
"used",
"if",
"you",
"are",
"using",
"servlets",
",",
"where",
"you",
"will",
"need",
"to",
"secure",
"the",
"connection",
"in",
"the",
"servlet",
"container"
] |
[
"public",
"synchronized",
"service",
"secure",
"(",
"string",
"keystore",
"file",
",",
"string",
"keystore",
"password",
",",
"string",
"cert",
"alias",
",",
"string",
"truststore",
"file",
",",
"string",
"truststore",
"password",
",",
"boolean",
"needs",
"client",
"cert",
")",
"{",
"if",
"(",
"initialized",
")",
"{",
"throw",
"before",
"route",
"mapping",
"exception",
"(",
")",
";",
"}",
"if",
"(",
"keystore",
"file",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"must",
"provide",
"a",
"keystore",
"file",
"to",
"run",
"secured",
"\"",
")",
";",
"}",
"ssl",
"stores",
"=",
"ssl",
"stores",
"create",
"(",
"keystore",
"file",
",",
"keystore",
"password",
",",
"cert",
"alias",
",",
"truststore",
"file",
",",
"truststore",
"password",
",",
"needs",
"client",
"cert",
")",
";",
"return",
"this",
";",
"}"
] |
[
"identifier",
"used",
"to",
"encode",
"this",
"strategy",
",",
"when",
"marshalled",
"as",
"part",
"of",
"a",
"bloom",
"filter",
"only",
"values",
"in",
"the",
"[",
"-",
"128",
",",
"127",
"]",
"range",
"are",
"valid",
"for",
"the",
"compact",
"serial",
"form",
"non",
"-",
"negative",
"values",
"are",
"reserved",
"for",
"enums",
"defined",
"in",
"bloom",
"filter",
"strategies",
";",
"negative",
"values",
"are",
"reserved",
"for",
"any",
"custom",
",",
"stateful",
"strategy",
"we",
"may",
"define",
"(",
"e",
"g",
"any",
"kind",
"of",
"strategy",
"that",
"would",
"depend",
"on",
"user",
"input",
")"
] |
[
"int",
"ordinal",
"(",
")",
";"
] |
[
"set",
"the",
"default",
"api",
"client",
",",
"which",
"would",
"be",
"used",
"when",
"creating",
"api",
"instances",
"without",
"providing",
"an",
"api",
"client"
] |
[
"public",
"static",
"void",
"set",
"default",
"api",
"client",
"(",
"api",
"client",
"api",
"client",
")",
"{",
"default",
"api",
"client",
"=",
"api",
"client",
";",
"}"
] |
[
"test",
"get",
"has",
"result",
"with",
"run",
"time",
"exception"
] |
[
"public",
"void",
"test",
"get",
"has",
"result",
"with",
"run",
"time",
"exception",
"(",
")",
"{",
"assertions",
"assert",
"throws",
"(",
"runtime",
"exception",
"class",
",",
"(",
")",
"-",
">",
"{",
"message",
"future",
"message",
"future",
"=",
"new",
"message",
"future",
"(",
")",
";",
"message",
"future",
"set",
"request",
"message",
"(",
"build",
"repc",
"message",
"(",
")",
")",
";",
"message",
"future",
"set",
"timeout",
"(",
"time",
"out",
"field",
")",
";",
"message",
"future",
"set",
"result",
"message",
"(",
"new",
"runtime",
"exception",
"(",
")",
")",
";",
"message",
"future",
"get",
"(",
"time",
"out",
"field",
",",
"time",
"unit",
"milliseconds",
")",
";",
"}",
")",
";",
"}"
] |
[
"sets",
"the",
"name",
"of",
"the",
"queue",
"for",
"which",
"we",
"are",
"requesting",
"a",
"policy",
"configuration"
] |
[
"public",
"abstract",
"void",
"set",
"queue",
"(",
"string",
"queue",
"name",
")",
";"
] |
[
"emits",
"an",
"(",
"implicit",
"or",
"explicit",
")",
"output",
"row",
"if",
"null",
"is",
"emitted",
"as",
"an",
"explicit",
"row",
",",
"it",
"will",
"be",
"skipped",
"by",
"the",
"runtime",
"for",
"implicit",
"rows",
",",
"the",
"row",
"'",
"s",
"field",
"will",
"be",
"null"
] |
[
"protected",
"final",
"void",
"collect",
"(",
"t",
"row",
")",
"{",
"collector",
"collect",
"(",
"row",
")",
";",
"}"
] |
[
"the",
"dispatcher",
"type",
"{",
"@",
"code",
"javax",
"servlet",
"dispatcher",
"type",
"async",
"}",
"introduced",
"in",
"servlet",
"3",
"0",
"means",
"a",
"filter",
"can",
"be",
"invoked",
"in",
"more",
"than",
"one",
"thread",
"over",
"the",
"course",
"of",
"a",
"single",
"request",
"this",
"method",
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"the",
"filter",
"is",
"currently",
"executing",
"within",
"an",
"asynchronous",
"dispatch"
] |
[
"protected",
"boolean",
"is",
"async",
"dispatch",
"(",
"http",
"servlet",
"request",
"request",
")",
"{",
"return",
"request",
"get",
"dispatcher",
"type",
"(",
")",
"equals",
"(",
"dispatcher",
"type",
"async",
")",
";",
"}"
] |
[
"gets",
"the",
"virtual",
"base",
"table",
"offset",
"in",
"this",
"rtti",
"4"
] |
[
"public",
"int",
"get",
"vb",
"table",
"offset",
"(",
")",
"throws",
"invalid",
"data",
"type",
"exception",
"{",
"check",
"validity",
"(",
")",
";",
"return",
"e",
"h",
"data",
"type",
"utilities",
"get",
"integer",
"value",
"(",
"get",
"data",
"type",
"(",
")",
",",
"vb",
"table",
"offset",
"ordinal",
",",
"get",
"mem",
"buffer",
"(",
")",
")",
";",
"}"
] |
[
"register",
"a",
"listener",
"that",
"will",
"be",
"called",
"when",
"this",
"model",
"visibility",
"state",
"has",
"changed",
"the",
"listener",
"will",
"contribute",
"to",
"this",
"model",
"'",
"s",
"hash",
"code",
"state",
"per",
"the",
"{",
"@",
"link",
"com",
"airbnb",
"epoxy",
"epoxy",
"attribute",
"option",
"#",
"do",
"not",
"hash",
"}",
"rules"
] |
[
"public",
"generate",
"default",
"layout",
"method",
"parent",
"layout",
"$",
"no",
"layout",
"on",
"visibility",
"state",
"changed",
"(",
"on",
"model",
"visibility",
"state",
"changed",
"listener",
"<",
"generate",
"default",
"layout",
"method",
"parent",
"layout",
"$",
"no",
"layout",
",",
"object",
">",
"listener",
")",
"{",
"on",
"mutation",
"(",
")",
";",
"this",
"on",
"model",
"visibility",
"state",
"changed",
"listener",
"epoxy",
"generated",
"model",
"=",
"listener",
";",
"return",
"this",
";",
"}"
] |
[
"convenience",
"routine",
"to",
"make",
"it",
"easy",
"to",
"return",
"the",
"most",
"interesting",
"words",
"in",
"a",
"document",
"more",
"advanced",
"users",
"will",
"call",
"{",
"@",
"link",
"#",
"retrieve",
"terms",
"(",
"reader",
",",
"string",
")",
"retrieve",
"terms",
"(",
")",
"}",
"directly"
] |
[
"public",
"string",
"[",
"]",
"retrieve",
"interesting",
"terms",
"(",
"reader",
"r",
",",
"string",
"field",
"name",
")",
"throws",
"i",
"o",
"exception",
"{",
"array",
"list",
"<",
"object",
">",
"al",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"max",
"query",
"terms",
")",
";",
"priority",
"queue",
"<",
"score",
"term",
">",
"pq",
"=",
"retrieve",
"terms",
"(",
"r",
",",
"field",
"name",
")",
";",
"score",
"term",
"score",
"term",
";",
"int",
"lim",
"=",
"max",
"query",
"terms",
";",
"/",
"/",
"have",
"to",
"be",
"careful",
",",
"retrieve",
"terms",
"returns",
"all",
"words",
"but",
"that",
"'",
"s",
"probably",
"not",
"useful",
"to",
"our",
"caller",
"/",
"/",
"we",
"just",
"want",
"to",
"return",
"the",
"top",
"words",
"while",
"(",
"(",
"(",
"score",
"term",
"=",
"pq",
"pop",
"(",
")",
")",
"!",
"=",
"null",
")",
"&",
"&",
"lim",
"-",
"-",
">",
"0",
")",
"{",
"al",
"add",
"(",
"score",
"term",
"word",
")",
";",
"/",
"/",
"the",
"1st",
"entry",
"is",
"the",
"interesting",
"word",
"}",
"string",
"[",
"]",
"res",
"=",
"new",
"string",
"[",
"al",
"size",
"(",
")",
"]",
";",
"return",
"al",
"to",
"array",
"(",
"res",
")",
";",
"}"
] |
[
"specify",
"filters",
"to",
"add",
"and",
"map",
"to",
"the",
"{",
"@",
"code",
"dispatcher",
"servlet",
"}"
] |
[
"protected",
"filter",
"[",
"]",
"get",
"servlet",
"filters",
"(",
")",
"{",
"return",
"null",
";",
"}"
] |
[
"store",
"a",
"key",
"at",
"the",
"specified",
"index"
] |
[
"private",
"void",
"put",
"key",
"(",
"int",
"index",
",",
"byte",
"[",
"]",
"key",
")",
"{",
"buffer",
"put",
"(",
"base",
"+",
"(",
"index",
"*",
"entry",
"size",
")",
",",
"key",
")",
";",
"}"
] |
[
"get",
"the",
"{",
"@",
"link",
"timeline",
"entity",
"group",
"id",
"}",
"s",
"for",
"the",
"data",
"sets",
"that",
"need",
"to",
"be",
"scanned",
"to",
"serve",
"the",
"query"
] |
[
"public",
"abstract",
"set",
"<",
"timeline",
"entity",
"group",
"id",
">",
"get",
"timeline",
"entity",
"group",
"id",
"(",
"string",
"entity",
"id",
",",
"string",
"entity",
"type",
")",
";"
] |
[
"request",
"a",
"set",
"of",
"session",
"credentials"
] |
[
"public",
"credentials",
"request",
"session",
"credentials",
"(",
"final",
"long",
"duration",
",",
"final",
"time",
"unit",
"time",
"unit",
")",
"throws",
"i",
"o",
"exception",
"{",
"int",
"duration",
"seconds",
"=",
"(",
"int",
")",
"time",
"unit",
"to",
"seconds",
"(",
"duration",
")",
";",
"log",
"debug",
"(",
"\"",
"requesting",
"session",
"token",
"of",
"duration",
"{",
"}",
"\"",
",",
"duration",
")",
";",
"final",
"get",
"session",
"token",
"request",
"request",
"=",
"new",
"get",
"session",
"token",
"request",
"(",
")",
";",
"request",
"set",
"duration",
"seconds",
"(",
"duration",
"seconds",
")",
";",
"return",
"invoker",
"retry",
"(",
"\"",
"request",
"session",
"credentials",
"\"",
",",
"\"",
"\"",
",",
"true",
",",
"(",
")",
"-",
">",
"{",
"log",
"info",
"(",
"\"",
"requesting",
"amazon",
"sts",
"session",
"credentials",
"\"",
")",
";",
"return",
"token",
"service",
"get",
"session",
"token",
"(",
"request",
")",
"get",
"credentials",
"(",
")",
";",
"}",
")",
";",
"}"
] |
[
"returns",
"an",
"immutable",
"set",
"of",
"all",
"nine",
"primitive",
"types",
"(",
"including",
"{",
"@",
"code",
"void",
"}",
")",
"note",
"that",
"a",
"simpler",
"way",
"to",
"test",
"whether",
"a",
"{",
"@",
"code",
"class",
"}",
"instance",
"is",
"a",
"member",
"of",
"this",
"set",
"is",
"to",
"call",
"{",
"@",
"link",
"class",
"#",
"is",
"primitive",
"}"
] |
[
"public",
"static",
"set",
"<",
"class",
"<",
"?",
">",
">",
"all",
"primitive",
"types",
"(",
")",
"{",
"return",
"primitive",
"to",
"wrapper",
"type",
"key",
"set",
"(",
")",
";",
"}"
] |
[
"does",
"not",
"require",
"the",
"argument"
] |
[
"string",
"get",
"execution",
"argument",
"(",
"int",
"daemon",
"id",
")",
"{",
"return",
"null",
";",
"}"
] |
[
"get",
"photo",
"urls"
] |
[
"public",
"list",
"<",
"string",
">",
"get",
"photo",
"urls",
"(",
")",
"{",
"return",
"photo",
"urls",
";",
"}"
] |
[
"load",
"a",
"pendingset",
"file",
"and",
"revert",
"all",
"of",
"its",
"contents"
] |
[
"private",
"void",
"load",
"and",
"revert",
"(",
"final",
"commit",
"operations",
"commit",
"context",
"commit",
"context",
",",
"final",
"active",
"commit",
"active",
"commit",
",",
"final",
"file",
"status",
"status",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"path",
"path",
"=",
"status",
"get",
"path",
"(",
")",
";",
"try",
"(",
"duration",
"info",
"ignored",
"=",
"new",
"duration",
"info",
"(",
"log",
",",
"false",
",",
"\"",
"committing",
"%",
"s",
"\"",
",",
"path",
")",
")",
"{",
"pending",
"set",
"pending",
"set",
"=",
"pending",
"set",
"load",
"(",
"active",
"commit",
"get",
"source",
"f",
"s",
"(",
")",
",",
"status",
")",
";",
"tasks",
"foreach",
"(",
"pending",
"set",
"get",
"commits",
"(",
")",
")",
"suppress",
"exceptions",
"(",
"true",
")",
"run",
"(",
"commit",
"context",
":",
":",
"revert",
"commit",
")",
";",
"}",
"}"
] |
[
"gets",
"date",
"time",
"for",
"zoned",
"date",
"time"
] |
[
"public",
"static",
"date",
"time",
"date",
"time",
"of",
"(",
"final",
"chrono",
"zoned",
"date",
"time",
"time",
")",
"{",
"return",
"date",
"time",
"of",
"(",
"time",
"to",
"instant",
"(",
")",
")",
";",
"}"
] |
[
"add",
"a",
"link",
"merge",
"to",
"the",
"config",
"for",
"the",
"default",
"mount",
"table"
] |
[
"public",
"static",
"void",
"add",
"link",
"merge",
"(",
"configuration",
"conf",
",",
"final",
"uri",
"[",
"]",
"targets",
")",
"{",
"add",
"link",
"merge",
"(",
"conf",
",",
"get",
"default",
"mount",
"table",
"name",
"(",
"conf",
")",
",",
"targets",
")",
";",
"}"
] |
[
"verify",
"leased",
"i",
"node",
"details",
"across",
"lease",
"get",
"and",
"release",
"from",
"{",
"@",
"link",
"lease",
"manager",
"#",
"get",
"i",
"node",
"id",
"with",
"leases",
"(",
")",
"}",
"and",
"{",
"@",
"link",
"lease",
"manager",
"#",
"get",
"i",
"node",
"with",
"leases",
"(",
"i",
"node",
"directory",
")",
"}"
] |
[
"public",
"void",
"test",
"inode",
"with",
"leases",
"for",
"ancestor",
"dir",
"(",
")",
"throws",
"exception",
"{",
"f",
"s",
"namesystem",
"fs",
"namesystem",
"=",
"make",
"mock",
"fs",
"name",
"system",
"(",
")",
";",
"f",
"s",
"directory",
"fs",
"directory",
"=",
"fs",
"namesystem",
"get",
"f",
"s",
"directory",
"(",
")",
";",
"lease",
"manager",
"lm",
"=",
"new",
"lease",
"manager",
"(",
"fs",
"namesystem",
")",
";",
"final",
"permission",
"status",
"perm",
"=",
"permission",
"status",
"create",
"immutable",
"(",
"\"",
"user",
"\"",
",",
"\"",
"group",
"\"",
",",
"fs",
"permission",
"create",
"immutable",
"(",
"(",
"short",
")",
"0755",
")",
")",
";",
"i",
"node",
"directory",
"root",
"inode",
"directory",
"=",
"new",
"i",
"node",
"directory",
"(",
"hdfs",
"constants",
"grandfather",
"inode",
"id",
",",
"d",
"f",
"s",
"util",
"string",
"2",
"bytes",
"(",
"\"",
"\"",
")",
",",
"perm",
",",
"0l",
")",
";",
"when",
"(",
"fs",
"directory",
"get",
"root",
"(",
")",
")",
"then",
"return",
"(",
"root",
"inode",
"directory",
")",
";",
"atomic",
"integer",
"inode",
"ids",
"=",
"new",
"atomic",
"integer",
"(",
"(",
"int",
")",
"(",
"hdfs",
"constants",
"grandfather",
"inode",
"id",
"+",
"1234",
")",
")",
";",
"string",
"[",
"]",
"path",
"tree",
"=",
"new",
"string",
"[",
"]",
"{",
"\"",
"/",
"root",
"log",
"\"",
",",
"\"",
"/",
"eng",
"/",
"a",
"/",
"a",
"1",
"log",
"\"",
",",
"\"",
"/",
"eng",
"/",
"a",
"/",
"b",
"/",
"b",
"1",
"log",
"\"",
",",
"\"",
"/",
"eng",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"c",
"1",
"log",
"\"",
",",
"\"",
"/",
"eng",
"/",
"a",
"/",
"b",
"/",
"c",
"/",
"c",
"2",
"log",
"\"",
",",
"\"",
"/",
"ops",
"/",
"m",
"/",
"m",
"1",
"log",
"\"",
",",
"\"",
"/",
"ops",
"/",
"m",
"/",
"n",
"/",
"n",
"1",
"log",
"\"",
",",
"\"",
"/",
"ops",
"/",
"m",
"/",
"n",
"/",
"n",
"2",
"log",
"\"",
"}",
";",
"map",
"<",
"string",
",",
"i",
"node",
">",
"path",
"i",
"node",
"map",
"=",
"create",
"i",
"node",
"tree",
"(",
"root",
"inode",
"directory",
",",
"path",
"tree",
",",
"inode",
"ids",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"lm",
"get",
"i",
"node",
"id",
"with",
"leases",
"(",
")",
"size",
"(",
")",
")",
";",
"for",
"(",
"entry",
"<",
"string",
",",
"i",
"node",
">",
"entry",
":",
"path",
"i",
"node",
"map",
"entry",
"set",
"(",
")",
")",
"{",
"long",
"i",
"node",
"id",
"=",
"entry",
"get",
"value",
"(",
")",
"get",
"id",
"(",
")",
";",
"when",
"(",
"fs",
"directory",
"get",
"inode",
"(",
"i",
"node",
"id",
")",
")",
"then",
"return",
"(",
"entry",
"get",
"value",
"(",
")",
")",
";",
"if",
"(",
"entry",
"get",
"key",
"(",
")",
"contains",
"(",
"\"",
"log",
"\"",
")",
")",
"{",
"lm",
"add",
"lease",
"(",
"\"",
"holder",
"\"",
"+",
"i",
"node",
"id",
",",
"i",
"node",
"id",
")",
";",
"}",
"}",
"assert",
"equals",
"(",
"path",
"tree",
"length",
",",
"lm",
"get",
"i",
"node",
"id",
"with",
"leases",
"(",
")",
"size",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"path",
"tree",
"length",
",",
"lm",
"get",
"i",
"node",
"with",
"leases",
"(",
")",
"size",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"path",
"tree",
"length",
",",
"lm",
"get",
"i",
"node",
"with",
"leases",
"(",
"root",
"inode",
"directory",
")",
"size",
"(",
")",
")",
";",
"/",
"/",
"reset",
"lm",
"remove",
"all",
"leases",
"(",
")",
";",
"set",
"<",
"string",
">",
"files",
"leased",
"=",
"new",
"hash",
"set",
"<",
">",
"(",
"arrays",
"as",
"list",
"(",
"\"",
"root",
"log",
"\"",
",",
"\"",
"a",
"1",
"log",
"\"",
",",
"\"",
"c",
"1",
"log",
"\"",
",",
"\"",
"n",
"2",
"log",
"\"",
")",
")",
";",
"for",
"(",
"string",
"file",
"name",
":",
"files",
"leased",
")",
"{",
"lm",
"add",
"lease",
"(",
"\"",
"holder",
"\"",
",",
"path",
"i",
"node",
"map",
"get",
"(",
"file",
"name",
")",
"get",
"id",
"(",
")",
")",
";",
"}",
"assert",
"equals",
"(",
"files",
"leased",
"size",
"(",
")",
",",
"lm",
"get",
"i",
"node",
"id",
"with",
"leases",
"(",
")",
"size",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"files",
"leased",
"size",
"(",
")",
",",
"lm",
"get",
"i",
"node",
"with",
"leases",
"(",
")",
"size",
"(",
")",
")",
";",
"set",
"<",
"i",
"nodes",
"in",
"path",
">",
"i",
"node",
"with",
"leases",
"=",
"lm",
"get",
"i",
"node",
"with",
"leases",
"(",
")",
";",
"for",
"(",
"i",
"nodes",
"in",
"path",
"i",
"nodes",
"in",
"path",
":",
"i",
"node",
"with",
"leases",
")",
"{",
"string",
"leased",
"file",
"name",
"=",
"d",
"f",
"s",
"util",
"bytes",
"2",
"string",
"(",
"i",
"nodes",
"in",
"path",
"get",
"last",
"local",
"name",
"(",
")",
")",
";",
"assert",
"true",
"(",
"files",
"leased",
"contains",
"(",
"leased",
"file",
"name",
")",
")",
";",
"}",
"assert",
"equals",
"(",
"files",
"leased",
"size",
"(",
")",
",",
"lm",
"get",
"i",
"node",
"with",
"leases",
"(",
"root",
"inode",
"directory",
")",
"size",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"files",
"leased",
"size",
"(",
")",
"-",
"2",
",",
"lm",
"get",
"i",
"node",
"with",
"leases",
"(",
"path",
"i",
"node",
"map",
"get",
"(",
"\"",
"eng",
"\"",
")",
"as",
"directory",
"(",
")",
")",
"size",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"files",
"leased",
"size",
"(",
")",
"-",
"2",
",",
"lm",
"get",
"i",
"node",
"with",
"leases",
"(",
"path",
"i",
"node",
"map",
"get",
"(",
"\"",
"a",
"\"",
")",
"as",
"directory",
"(",
")",
")",
"size",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"files",
"leased",
"size",
"(",
")",
"-",
"3",
",",
"lm",
"get",
"i",
"node",
"with",
"leases",
"(",
"path",
"i",
"node",
"map",
"get",
"(",
"\"",
"c",
"\"",
")",
"as",
"directory",
"(",
")",
")",
"size",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"files",
"leased",
"size",
"(",
")",
"-",
"3",
",",
"lm",
"get",
"i",
"node",
"with",
"leases",
"(",
"path",
"i",
"node",
"map",
"get",
"(",
"\"",
"ops",
"\"",
")",
"as",
"directory",
"(",
")",
")",
"size",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"files",
"leased",
"size",
"(",
")",
"-",
"3",
",",
"lm",
"get",
"i",
"node",
"with",
"leases",
"(",
"path",
"i",
"node",
"map",
"get",
"(",
"\"",
"n",
"\"",
")",
"as",
"directory",
"(",
")",
")",
"size",
"(",
")",
")",
";",
"lm",
"remove",
"lease",
"(",
"path",
"i",
"node",
"map",
"get",
"(",
"\"",
"n",
"2",
"log",
"\"",
")",
"get",
"id",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"files",
"leased",
"size",
"(",
")",
"-",
"1",
",",
"lm",
"get",
"i",
"node",
"with",
"leases",
"(",
"root",
"inode",
"directory",
")",
"size",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"files",
"leased",
"size",
"(",
")",
"-",
"4",
",",
"lm",
"get",
"i",
"node",
"with",
"leases",
"(",
"path",
"i",
"node",
"map",
"get",
"(",
"\"",
"n",
"\"",
")",
"as",
"directory",
"(",
")",
")",
"size",
"(",
")",
")",
";",
"lm",
"remove",
"all",
"leases",
"(",
")",
";",
"files",
"leased",
"clear",
"(",
")",
";",
"assert",
"equals",
"(",
"files",
"leased",
"size",
"(",
")",
",",
"lm",
"get",
"i",
"node",
"with",
"leases",
"(",
"root",
"inode",
"directory",
")",
"size",
"(",
")",
")",
";",
"}"
] |
[
"skip",
"all",
"the",
"prefixes",
"associated",
"with",
"starlark",
"options"
] |
[
"public",
"builder",
"skip",
"starlark",
"option",
"prefixes",
"(",
")",
"{",
"for",
"(",
"string",
"prefix",
":",
"starlark",
"skipped",
"prefixes",
")",
"{",
"this",
"impl",
"builder",
"skipped",
"prefix",
"(",
"prefix",
")",
";",
"}",
"return",
"this",
";",
"}"
] |
[
"transfers",
"data",
"from",
"file",
"channel",
"using",
"{",
"@",
"link",
"file",
"channel",
"#",
"transfer",
"to",
"(",
"long",
",",
"long",
",",
"writable",
"byte",
"channel",
")",
"}",
"updates",
"<",
"code",
">",
"wait",
"for",
"writable",
"time",
"<",
"code",
">",
"and",
"<",
"code",
">",
"transfer",
"to",
"time",
"<",
"code",
">",
"with",
"the",
"time",
"spent",
"blocked",
"on",
"the",
"network",
"and",
"the",
"time",
"spent",
"transferring",
"data",
"from",
"disk",
"to",
"network",
"respectively",
"similar",
"to",
"read",
"fully",
"(",
")",
",",
"this",
"waits",
"till",
"requested",
"amount",
"of",
"data",
"is",
"transfered"
] |
[
"public",
"void",
"transfer",
"to",
"fully",
"(",
"file",
"channel",
"file",
"ch",
",",
"long",
"position",
",",
"int",
"count",
",",
"long",
"writable",
"wait",
"for",
"writable",
"time",
",",
"long",
"writable",
"transfer",
"to",
"time",
")",
"throws",
"i",
"o",
"exception",
"{",
"long",
"wait",
"time",
"=",
"0",
";",
"long",
"transfer",
"time",
"=",
"0",
";",
"while",
"(",
"count",
">",
"0",
")",
"{",
"/",
"*",
"*",
"ideally",
"we",
"should",
"wait",
"after",
"transfer",
"to",
"returns",
"0",
"but",
"because",
"of",
"*",
"a",
"bug",
"in",
"jre",
"on",
"linux",
"(",
"http",
":",
"/",
"/",
"bugs",
"sun",
"com",
"/",
"view",
"bug",
"do",
"?",
"bug",
"id",
"=",
"5103988",
")",
",",
"*",
"which",
"throws",
"an",
"exception",
"instead",
"of",
"returning",
"0",
",",
"we",
"wait",
"for",
"the",
"*",
"channel",
"to",
"be",
"writable",
"before",
"writing",
"to",
"it",
"if",
"you",
"ever",
"see",
"*",
"i",
"o",
"exception",
"with",
"message",
"\"",
"resource",
"temporarily",
"unavailable",
"\"",
"*",
"thrown",
"here",
",",
"please",
"let",
"us",
"know",
"*",
"*",
"once",
"we",
"move",
"to",
"java",
"se",
"7",
",",
"wait",
"should",
"be",
"moved",
"to",
"correct",
"place",
"*",
"/",
"long",
"start",
"=",
"system",
"nano",
"time",
"(",
")",
";",
"wait",
"for",
"writable",
"(",
")",
";",
"long",
"wait",
"=",
"system",
"nano",
"time",
"(",
")",
";",
"int",
"n",
"transfered",
"=",
"(",
"int",
")",
"file",
"ch",
"transfer",
"to",
"(",
"position",
",",
"count",
",",
"get",
"channel",
"(",
")",
")",
";",
"if",
"(",
"n",
"transfered",
"=",
"=",
"0",
")",
"{",
"/",
"/",
"check",
"if",
"end",
"of",
"file",
"is",
"reached",
"if",
"(",
"position",
">",
"=",
"file",
"ch",
"size",
"(",
")",
")",
"{",
"throw",
"new",
"e",
"o",
"f",
"exception",
"(",
"\"",
"eof",
"reached",
"file",
"size",
"is",
"\"",
"+",
"file",
"ch",
"size",
"(",
")",
"+",
"\"",
"and",
"\"",
"+",
"count",
"+",
"\"",
"more",
"bytes",
"left",
"to",
"be",
"\"",
"+",
"\"",
"transfered",
"\"",
")",
";",
"}",
"/",
"/",
"otherwise",
"assume",
"the",
"socket",
"is",
"full",
"/",
"/",
"wait",
"for",
"writable",
"(",
")",
";",
"/",
"/",
"see",
"comment",
"above",
"}",
"else",
"if",
"(",
"n",
"transfered",
"<",
"0",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"unexpected",
"return",
"of",
"\"",
"+",
"n",
"transfered",
"+",
"\"",
"from",
"transfer",
"to",
"(",
")",
"\"",
")",
";",
"}",
"else",
"{",
"position",
"+",
"=",
"n",
"transfered",
";",
"count",
"-",
"=",
"n",
"transfered",
";",
"}",
"long",
"transfer",
"=",
"system",
"nano",
"time",
"(",
")",
";",
"wait",
"time",
"+",
"=",
"wait",
"-",
"start",
";",
"transfer",
"time",
"+",
"=",
"transfer",
"-",
"wait",
";",
"}",
"if",
"(",
"wait",
"for",
"writable",
"time",
"!",
"=",
"null",
")",
"{",
"wait",
"for",
"writable",
"time",
"set",
"(",
"wait",
"time",
")",
";",
"}",
"if",
"(",
"transfer",
"to",
"time",
"!",
"=",
"null",
")",
"{",
"transfer",
"to",
"time",
"set",
"(",
"transfer",
"time",
")",
";",
"}",
"}"
] |
[
"gets",
"current",
"status"
] |
[
"public",
"list",
"<",
"disk",
"balancer",
"work",
"entry",
">",
"get",
"current",
"state",
"(",
")",
"{",
"return",
"current",
"state",
";",
"}"
] |
[
"provides",
"configuration",
"information",
"for",
"the",
"policy",
"from",
"the",
"scheduler",
"configuration"
] |
[
"public",
"void",
"configure",
"(",
"map",
"<",
"string",
",",
"string",
">",
"conf",
")",
";"
] |
[
"get",
"map",
"map",
"of",
"string"
] |
[
"public",
"map",
"<",
"string",
",",
"map",
"<",
"string",
",",
"string",
">",
">",
"get",
"map",
"map",
"of",
"string",
"(",
")",
"{",
"return",
"map",
"map",
"of",
"string",
";",
"}"
] |
[
"called",
"when",
"an",
"object",
"is",
"freed",
"to",
"clear",
"the",
"state",
"of",
"the",
"object",
"for",
"possible",
"later",
"reuse",
"the",
"default",
"implementation",
"calls",
"{",
"@",
"link",
"poolable",
"#",
"reset",
"(",
")",
"}",
"if",
"the",
"object",
"is",
"{",
"@",
"link",
"poolable",
"}"
] |
[
"protected",
"void",
"reset",
"(",
"t",
"object",
")",
"{",
"if",
"(",
"object",
"instanceof",
"poolable",
")",
"(",
"(",
"poolable",
")",
"object",
")",
"reset",
"(",
")",
";",
"}"
] |
[
"test",
"for",
"downloading",
"a",
"checkpoint",
"made",
"at",
"a",
"later",
"checkpoint",
"from",
"the",
"active"
] |
[
"public",
"void",
"test",
"downloading",
"later",
"checkpoint",
"(",
")",
"throws",
"exception",
"{",
"/",
"/",
"roll",
"edit",
"logs",
"a",
"few",
"times",
"to",
"inflate",
"txid",
"nn",
"0",
"get",
"rpc",
"server",
"(",
")",
"roll",
"edit",
"log",
"(",
")",
";",
"nn",
"0",
"get",
"rpc",
"server",
"(",
")",
"roll",
"edit",
"log",
"(",
")",
";",
"/",
"/",
"make",
"checkpoint",
"name",
"node",
"adapter",
"enter",
"safe",
"mode",
"(",
"nn",
"0",
",",
"false",
")",
";",
"name",
"node",
"adapter",
"save",
"namespace",
"(",
"nn",
"0",
")",
";",
"name",
"node",
"adapter",
"leave",
"safe",
"mode",
"(",
"nn",
"0",
")",
";",
"long",
"expected",
"checkpoint",
"tx",
"id",
"=",
"name",
"node",
"adapter",
"get",
"namesystem",
"(",
"nn",
"0",
")",
"get",
"f",
"s",
"image",
"(",
")",
"get",
"most",
"recent",
"checkpoint",
"tx",
"id",
"(",
")",
";",
"assert",
"equals",
"(",
"6",
",",
"expected",
"checkpoint",
"tx",
"id",
")",
";",
"/",
"/",
"advance",
"the",
"current",
"txid",
"cluster",
"get",
"file",
"system",
"(",
"0",
")",
"create",
"(",
"new",
"path",
"(",
"\"",
"/",
"test",
"txid",
"\"",
")",
",",
"(",
"short",
")",
"1",
")",
"close",
"(",
")",
";",
"/",
"/",
"obtain",
"the",
"content",
"of",
"seen",
"txid",
"uri",
"edits",
"uri",
"=",
"cluster",
"get",
"shared",
"edits",
"dir",
"(",
"0",
",",
"max",
"n",
"n",
"count",
"-",
"1",
")",
";",
"long",
"seen",
"txid",
"shared",
"=",
"f",
"s",
"image",
"test",
"util",
"get",
"storage",
"tx",
"id",
"(",
"nn",
"0",
",",
"edits",
"uri",
")",
";",
"for",
"(",
"int",
"i",
"=",
"1",
";",
"i",
"<",
"max",
"n",
"n",
"count",
";",
"i",
"+",
"+",
")",
"{",
"assert",
"equals",
"(",
"0",
",",
"force",
"bootstrap",
"(",
"i",
")",
")",
";",
"/",
"/",
"should",
"have",
"copied",
"over",
"the",
"namespace",
"from",
"the",
"active",
"log",
"info",
"(",
"\"",
"checking",
"namenode",
":",
"\"",
"+",
"i",
")",
";",
"f",
"s",
"image",
"test",
"util",
"assert",
"n",
"n",
"has",
"checkpoints",
"(",
"cluster",
",",
"i",
",",
"immutable",
"list",
"of",
"(",
"(",
"int",
")",
"expected",
"checkpoint",
"tx",
"id",
")",
")",
";",
"}",
"f",
"s",
"image",
"test",
"util",
"assert",
"n",
"n",
"files",
"match",
"(",
"cluster",
")",
";",
"/",
"/",
"make",
"sure",
"the",
"seen",
"txid",
"was",
"not",
"modified",
"by",
"the",
"standby",
"assert",
"equals",
"(",
"seen",
"txid",
"shared",
",",
"f",
"s",
"image",
"test",
"util",
"get",
"storage",
"tx",
"id",
"(",
"nn",
"0",
",",
"edits",
"uri",
")",
")",
";",
"/",
"/",
"we",
"should",
"now",
"be",
"able",
"to",
"start",
"the",
"standby",
"successfully",
"restart",
"name",
"nodes",
"from",
"index",
"(",
"1",
")",
";",
"}"
] |
[
"creates",
"a",
"new",
"tsi",
"handshaker",
"for",
"use",
"by",
"the",
"server"
] |
[
"public",
"static",
"tsi",
"handshaker",
"new",
"server",
"(",
"handshaker",
"service",
"stub",
"stub",
",",
"alts",
"handshaker",
"options",
"options",
")",
"{",
"return",
"new",
"alts",
"tsi",
"handshaker",
"(",
"false",
",",
"stub",
",",
"options",
")",
";",
"}"
] |
[
"establish",
"connectivity",
"to",
"a",
"vertex",
"that",
"precedes",
"the",
"first",
"vertex",
"don",
"'",
"t",
"call",
"this",
"for",
"loops"
] |
[
"public",
"void",
"set",
"prev",
"vertex",
"(",
"float",
"prev",
"vertex",
"x",
",",
"float",
"prev",
"vertex",
"y",
")",
"{",
"jni",
"set",
"prev",
"vertex",
"(",
"addr",
",",
"prev",
"vertex",
"x",
",",
"prev",
"vertex",
"y",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"triangle",
"type",
"'"
] |
[
"public",
"void",
"triangle",
"type",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"triangle",
"type",
"}"
] |
[
"test",
"the",
"property",
"'",
"uuid",
"'"
] |
[
"public",
"void",
"uuid",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"uuid",
"}"
] |
[
"this",
"infers",
"the",
"desired",
"byte",
"address",
"within",
"a",
"function",
"based",
"on",
"the",
"code",
"units",
"at",
"<",
"code",
">",
"address",
"<",
"code",
">",
"and",
"<",
"code",
">",
"desired",
"address",
"<",
"code",
">",
"if",
"the",
"inferred",
"address",
"would",
"be",
"beyond",
"the",
"last",
"byte",
"of",
"the",
"code",
"unit",
"then",
"it",
"will",
"get",
"set",
"to",
"the",
"last",
"byte",
"of",
"the",
"code",
"unit",
"at",
"the",
"<",
"code",
">",
"desired",
"address",
"<",
"code",
">"
] |
[
"private",
"address",
"infer",
"desired",
"function",
"address",
"(",
"address",
"address",
",",
"address",
"desired",
"address",
",",
"address",
"byte",
"address",
",",
"program",
"program",
",",
"program",
"desired",
"program",
")",
"{",
"long",
"num",
"bytes",
"into",
"code",
"unit",
"=",
"byte",
"address",
"subtract",
"(",
"address",
")",
";",
"if",
"(",
"num",
"bytes",
"into",
"code",
"unit",
"=",
"=",
"0",
")",
"{",
"return",
"desired",
"address",
";",
"}",
"if",
"(",
"num",
"bytes",
"into",
"code",
"unit",
">",
"0",
")",
"{",
"code",
"unit",
"code",
"unit",
"=",
"program",
"get",
"listing",
"(",
")",
"get",
"code",
"unit",
"at",
"(",
"address",
")",
";",
"code",
"unit",
"desired",
"code",
"unit",
"=",
"desired",
"program",
"get",
"listing",
"(",
")",
"get",
"code",
"unit",
"at",
"(",
"desired",
"address",
")",
";",
"if",
"(",
"code",
"unit",
"!",
"=",
"null",
"&",
"&",
"desired",
"code",
"unit",
"!",
"=",
"null",
")",
"{",
"int",
"desired",
"code",
"unit",
"length",
"=",
"desired",
"code",
"unit",
"get",
"length",
"(",
")",
";",
"if",
"(",
"num",
"bytes",
"into",
"code",
"unit",
"<",
"desired",
"code",
"unit",
"length",
")",
"{",
"/",
"/",
"position",
"at",
"byte",
"within",
"code",
"unit",
"return",
"desired",
"address",
"add",
"(",
"num",
"bytes",
"into",
"code",
"unit",
")",
";",
"}",
"/",
"/",
"otherwise",
"position",
"at",
"last",
"byte",
"of",
"code",
"unit",
"return",
"desired",
"address",
"add",
"(",
"desired",
"code",
"unit",
"length",
"-",
"1",
")",
";",
"}",
"}",
"return",
"null",
";",
"}"
] |
[
"creates",
"a",
"thread",
"using",
"{",
"@",
"link",
"#",
"platform",
"thread",
"factory",
"}",
",",
"and",
"sets",
"its",
"name",
"to",
"{",
"@",
"code",
"name",
"}",
"unless",
"changing",
"the",
"name",
"is",
"forbidden",
"by",
"the",
"security",
"manager"
] |
[
"static",
"thread",
"new",
"thread",
"(",
"string",
"name",
",",
"runnable",
"runnable",
")",
"{",
"check",
"not",
"null",
"(",
"name",
")",
";",
"check",
"not",
"null",
"(",
"runnable",
")",
";",
"thread",
"result",
"=",
"platform",
"thread",
"factory",
"(",
")",
"new",
"thread",
"(",
"runnable",
")",
";",
"try",
"{",
"result",
"set",
"name",
"(",
"name",
")",
";",
"}",
"catch",
"(",
"security",
"exception",
"e",
")",
"{",
"/",
"/",
"ok",
"if",
"we",
"can",
"'",
"t",
"set",
"the",
"name",
"in",
"this",
"environment",
"}",
"return",
"result",
";",
"}",
"/",
"/",
"todo",
"(",
"lukes",
")",
":",
"provide",
"overloads",
"for",
"listening",
"executor",
"service",
"?",
"listening",
"scheduled",
"executor",
"service",
"?",
"/",
"/",
"todo",
"(",
"lukes",
")",
":",
"provide",
"overloads",
"that",
"take",
"constant",
"strings",
"?",
"function",
"<",
"runnable",
",",
"string",
">",
"s",
"to",
"/",
"/",
"calculate",
"names",
"?"
] |
[
"configures",
"to",
"start",
"reading",
"from",
"any",
"committed",
"group",
"offsets",
"found",
"in",
"zookeeper",
"kafka",
"brokers"
] |
[
"public",
"kafka",
"start",
"from",
"group",
"offsets",
"(",
")",
"{",
"this",
"startup",
"mode",
"=",
"startup",
"mode",
"group",
"offsets",
";",
"this",
"specific",
"offsets",
"=",
"null",
";",
"return",
"this",
";",
"}"
] |
[
"returns",
"an",
"array",
"containing",
"all",
"the",
"short",
"keys"
] |
[
"public",
"short",
"[",
"]",
"get",
"keys",
"(",
")",
"{",
"return",
"indexer",
"get",
"keys",
"(",
")",
";",
"}"
] |
[
"get",
"photo",
"urls"
] |
[
"public",
"list",
"<",
"string",
">",
"get",
"photo",
"urls",
"(",
")",
"{",
"return",
"photo",
"urls",
";",
"}"
] |
[
"returns",
"the",
"{",
"@",
"code",
"long",
"}",
"value",
"present",
"at",
"the",
"given",
"index"
] |
[
"public",
"long",
"get",
"(",
"int",
"index",
")",
"{",
"preconditions",
"check",
"element",
"index",
"(",
"index",
",",
"length",
"(",
")",
")",
";",
"return",
"array",
"[",
"start",
"+",
"index",
"]",
";",
"}"
] |
[
"creates",
"a",
"format",
"from",
"the",
"given",
"context",
"and",
"format",
"options",
"the",
"format",
"options",
"have",
"been",
"projected",
"to",
"top",
"-",
"level",
"options",
"(",
"e",
"g",
"from",
"{",
"@",
"code",
"format",
"ignore",
"-",
"errors",
"}",
"to",
"{",
"@",
"code",
"ignore",
"-",
"errors",
"}",
")"
] |
[
"encoding",
"format",
"<",
"i",
">",
"create",
"encoding",
"format",
"(",
"dynamic",
"table",
"factory",
"context",
"context",
",",
"readable",
"config",
"format",
"options",
")",
";"
] |
[
"given",
"the",
"configuration",
"for",
"this",
"node",
",",
"return",
"a",
"list",
"of",
"configurations",
"for",
"the",
"other",
"nodes",
"in",
"an",
"ha",
"setup"
] |
[
"public",
"static",
"list",
"<",
"configuration",
">",
"get",
"conf",
"for",
"other",
"nodes",
"(",
"configuration",
"my",
"conf",
")",
"{",
"string",
"ns",
"id",
"=",
"d",
"f",
"s",
"util",
"get",
"namenode",
"name",
"service",
"id",
"(",
"my",
"conf",
")",
";",
"list",
"<",
"string",
">",
"other",
"nodes",
"=",
"get",
"name",
"node",
"id",
"of",
"other",
"nodes",
"(",
"my",
"conf",
",",
"ns",
"id",
")",
";",
"/",
"/",
"look",
"up",
"the",
"address",
"of",
"the",
"other",
"n",
"ns",
"list",
"<",
"configuration",
">",
"confs",
"=",
"new",
"array",
"list",
"<",
"configuration",
">",
"(",
"other",
"nodes",
"size",
"(",
")",
")",
";",
"my",
"conf",
"=",
"new",
"configuration",
"(",
"my",
"conf",
")",
";",
"/",
"/",
"unset",
"independent",
"properties",
"for",
"(",
"string",
"idp",
"key",
":",
"ha",
"special",
"independent",
"keys",
")",
"{",
"my",
"conf",
"unset",
"(",
"idp",
"key",
")",
";",
"}",
"for",
"(",
"string",
"nn",
":",
"other",
"nodes",
")",
"{",
"configuration",
"conf",
"for",
"other",
"node",
"=",
"new",
"configuration",
"(",
"my",
"conf",
")",
";",
"name",
"node",
"initialize",
"generic",
"keys",
"(",
"conf",
"for",
"other",
"node",
",",
"ns",
"id",
",",
"nn",
")",
";",
"confs",
"add",
"(",
"conf",
"for",
"other",
"node",
")",
";",
"}",
"return",
"confs",
";",
"}"
] |
[
"judge",
"the",
"passed",
"in",
"column",
"is",
"an",
"id",
"column",
"or",
"not",
"the",
"column",
"named",
"id",
"or",
"id",
"will",
"be",
"considered",
"as",
"id",
"column"
] |
[
"protected",
"boolean",
"is",
"id",
"column",
"(",
"string",
"column",
"name",
")",
"{",
"return",
"\"",
"id",
"\"",
"equals",
"ignore",
"case",
"(",
"column",
"name",
")",
"|",
"|",
"\"",
"id",
"\"",
"equals",
"ignore",
"case",
"(",
"column",
"name",
")",
";",
"}"
] |
[
"returns",
"all",
"artifacts",
"to",
"build",
"if",
"this",
"target",
"is",
"requested",
"as",
"a",
"top",
"-",
"level",
"target",
"the",
"resulting",
"set",
"includes",
"the",
"temps",
"and",
"either",
"the",
"files",
"to",
"compile",
",",
"if",
"{",
"@",
"code",
"context",
"compile",
"only",
"(",
")",
"=",
"=",
"true",
"}",
",",
"or",
"the",
"files",
"to",
"run",
"calls",
"to",
"this",
"method",
"should",
"generally",
"return",
"quickly",
";",
"however",
",",
"the",
"runfiles",
"computation",
"can",
"be",
"lazy",
",",
"in",
"which",
"case",
"it",
"can",
"be",
"expensive",
"on",
"the",
"first",
"call",
"subsequent",
"calls",
"may",
"or",
"may",
"not",
"return",
"the",
"same",
"{",
"@",
"code",
"iterable",
"}",
"instance"
] |
[
"public",
"static",
"artifacts",
"to",
"build",
"get",
"all",
"artifacts",
"to",
"build",
"(",
"provider",
"collection",
"target",
",",
"top",
"level",
"artifact",
"context",
"context",
")",
"{",
"return",
"get",
"all",
"artifacts",
"to",
"build",
"(",
"output",
"group",
"info",
"get",
"(",
"target",
")",
",",
"target",
"get",
"provider",
"(",
"file",
"provider",
"class",
")",
",",
"context",
")",
";",
"}"
] |
[
"get",
"date",
"time"
] |
[
"public",
"offset",
"date",
"time",
"get",
"date",
"time",
"(",
")",
"{",
"return",
"date",
"time",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"prefix",
"ns",
"number",
"'"
] |
[
"public",
"void",
"prefix",
"ns",
"number",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"prefix",
"ns",
"number",
"}"
] |
[
"add",
"a",
"servlet",
"in",
"the",
"server"
] |
[
"public",
"void",
"add",
"servlet",
"(",
"string",
"name",
",",
"string",
"path",
"spec",
",",
"class",
"<",
"?",
"extends",
"http",
"servlet",
">",
"clazz",
")",
"{",
"add",
"internal",
"servlet",
"(",
"name",
",",
"path",
"spec",
",",
"clazz",
",",
"false",
")",
";",
"}"
] |
[
"creates",
"a",
"new",
"set",
"of",
"rotation",
"options",
"for",
"jpeg",
"images",
"to",
"load",
"image",
"without",
"any",
"rotation"
] |
[
"public",
"static",
"rotation",
"options",
"disable",
"rotation",
"(",
")",
"{",
"return",
"rotation",
"options",
"disable",
"rotation",
";",
"}"
] |
[
"the",
"real",
"main",
"function",
",",
"which",
"takes",
"the",
"arguments",
"as",
"a",
"list",
"argument",
"0",
"must",
"be",
"the",
"service",
"classname"
] |
[
"static",
"void",
"service",
"main",
"(",
"final",
"list",
"<",
"string",
">",
"args",
"list",
",",
"final",
"abstract",
"s",
"3",
"guard",
"dynamo",
"d",
"b",
"diagnostic",
"service",
")",
"{",
"service",
"launcher",
"<",
"service",
">",
"service",
"launcher",
"=",
"new",
"service",
"launcher",
"<",
">",
"(",
"service",
"get",
"name",
"(",
")",
")",
";",
"exit",
"util",
"exit",
"exception",
"ex",
"=",
"service",
"launcher",
"launch",
"service",
"(",
"new",
"configuration",
"(",
")",
",",
"service",
",",
"args",
"list",
",",
"false",
",",
"true",
")",
";",
"if",
"(",
"ex",
"!",
"=",
"null",
")",
"{",
"throw",
"ex",
";",
"}",
"}"
] |
[
"sets",
"the",
"values",
"of",
"this",
"variable",
"under",
"a",
"specific",
"key"
] |
[
"public",
"void",
"set",
"choices",
"(",
"object",
"key",
",",
"object",
"[",
"]",
"values",
")",
"{",
"assert",
"is",
"not",
"null",
"(",
"key",
")",
";",
"assert",
"is",
"true",
"(",
"values",
"length",
">",
"0",
")",
";",
"/",
"/",
"no",
"action",
"when",
"called",
"from",
"super",
"ctor",
"if",
"(",
"f",
"value",
"map",
"!",
"=",
"null",
")",
"{",
"f",
"value",
"map",
"put",
"(",
"key",
",",
"values",
")",
";",
"if",
"(",
"key",
"equals",
"(",
"f",
"key",
")",
")",
"f",
"current",
"choice",
"=",
"get",
"choices",
"(",
")",
"[",
"0",
"]",
";",
"set",
"resolved",
"(",
"true",
")",
";",
"}",
"}"
] |
[
"start",
"checkpoint",
"if",
"backup",
"storage",
"contains",
"image",
"that",
"is",
"newer",
"than",
"or",
"incompatible",
"with",
"what",
"the",
"active",
"name",
"-",
"node",
"has",
",",
"then",
"the",
"backup",
"node",
"should",
"shutdown",
"<",
"br",
">",
"if",
"the",
"backup",
"image",
"is",
"older",
"than",
"the",
"active",
"one",
"then",
"it",
"should",
"be",
"discarded",
"and",
"downloaded",
"from",
"the",
"active",
"node",
"<",
"br",
">",
"if",
"the",
"images",
"are",
"the",
"same",
"then",
"the",
"backup",
"image",
"will",
"be",
"used",
"as",
"current"
] |
[
"namenode",
"command",
"start",
"checkpoint",
"(",
"namenode",
"registration",
"bn",
"reg",
",",
"/",
"/",
"backup",
"node",
"namenode",
"registration",
"nn",
"reg",
",",
"int",
"layout",
"version",
")",
"/",
"/",
"active",
"name",
"-",
"node",
"throws",
"i",
"o",
"exception",
"{",
"log",
"info",
"(",
"\"",
"start",
"checkpoint",
"at",
"txid",
"\"",
"+",
"get",
"edit",
"log",
"(",
")",
"get",
"last",
"written",
"tx",
"id",
"(",
")",
")",
";",
"string",
"msg",
"=",
"null",
";",
"/",
"/",
"verify",
"that",
"checkpoint",
"is",
"allowed",
"if",
"(",
"bn",
"reg",
"get",
"namespace",
"i",
"d",
"(",
")",
"!",
"=",
"storage",
"get",
"namespace",
"i",
"d",
"(",
")",
")",
"msg",
"=",
"\"",
"name",
"node",
"\"",
"+",
"bn",
"reg",
"get",
"address",
"(",
")",
"+",
"\"",
"has",
"incompatible",
"namespace",
"id",
":",
"\"",
"+",
"bn",
"reg",
"get",
"namespace",
"i",
"d",
"(",
")",
"+",
"\"",
"expected",
":",
"\"",
"+",
"storage",
"get",
"namespace",
"i",
"d",
"(",
")",
";",
"else",
"if",
"(",
"bn",
"reg",
"is",
"role",
"(",
"namenode",
"role",
"namenode",
")",
")",
"msg",
"=",
"\"",
"name",
"node",
"\"",
"+",
"bn",
"reg",
"get",
"address",
"(",
")",
"+",
"\"",
"role",
"\"",
"+",
"bn",
"reg",
"get",
"role",
"(",
")",
"+",
"\"",
":",
"checkpoint",
"is",
"not",
"allowed",
"\"",
";",
"else",
"if",
"(",
"bn",
"reg",
"get",
"layout",
"version",
"(",
")",
"<",
"storage",
"get",
"layout",
"version",
"(",
")",
"|",
"|",
"(",
"bn",
"reg",
"get",
"layout",
"version",
"(",
")",
"=",
"=",
"storage",
"get",
"layout",
"version",
"(",
")",
"&",
"&",
"bn",
"reg",
"get",
"c",
"time",
"(",
")",
">",
"storage",
"get",
"c",
"time",
"(",
")",
")",
")",
"/",
"/",
"remote",
"node",
"has",
"newer",
"image",
"age",
"msg",
"=",
"\"",
"name",
"node",
"\"",
"+",
"bn",
"reg",
"get",
"address",
"(",
")",
"+",
"\"",
"has",
"newer",
"image",
"layout",
"version",
":",
"lv",
"=",
"\"",
"+",
"bn",
"reg",
"get",
"layout",
"version",
"(",
")",
"+",
"\"",
"c",
"time",
"=",
"\"",
"+",
"bn",
"reg",
"get",
"c",
"time",
"(",
")",
"+",
"\"",
"current",
"version",
":",
"lv",
"=",
"\"",
"+",
"storage",
"get",
"layout",
"version",
"(",
")",
"+",
"\"",
"c",
"time",
"=",
"\"",
"+",
"storage",
"get",
"c",
"time",
"(",
")",
";",
"if",
"(",
"msg",
"!",
"=",
"null",
")",
"{",
"log",
"error",
"(",
"msg",
")",
";",
"return",
"new",
"namenode",
"command",
"(",
"namenode",
"protocol",
"act",
"shutdown",
")",
";",
"}",
"boolean",
"need",
"to",
"return",
"img",
"=",
"true",
";",
"if",
"(",
"storage",
"get",
"num",
"storage",
"dirs",
"(",
"name",
"node",
"dir",
"type",
"image",
")",
"=",
"=",
"0",
")",
"/",
"/",
"do",
"not",
"return",
"image",
"if",
"there",
"are",
"no",
"image",
"directories",
"need",
"to",
"return",
"img",
"=",
"false",
";",
"checkpoint",
"signature",
"sig",
"=",
"roll",
"edit",
"log",
"(",
"layout",
"version",
")",
";",
"return",
"new",
"checkpoint",
"command",
"(",
"sig",
",",
"need",
"to",
"return",
"img",
")",
";",
"}"
] |
[
"gets",
"web",
"finger",
"response"
] |
[
"public",
"response",
"entity",
"get",
"web",
"finger",
"response",
"(",
"@",
"request",
"param",
"(",
"\"",
"resource",
"\"",
")",
"final",
"string",
"resource",
",",
"@",
"request",
"param",
"(",
"value",
"=",
"\"",
"rel",
"\"",
",",
"required",
"=",
"false",
")",
"final",
"string",
"rel",
")",
"{",
"return",
"web",
"finger",
"discovery",
"service",
"handle",
"web",
"finger",
"discovery",
"request",
"(",
"resource",
",",
"rel",
")",
";",
"}"
] |
[
"sets",
"a",
"built",
"-",
"in",
"watermark",
"strategy",
"for",
"ascending",
"rowtime",
"attributes",
"emits",
"a",
"watermark",
"of",
"the",
"maximum",
"observed",
"timestamp",
"so",
"far",
"minus",
"1",
"rows",
"that",
"have",
"a",
"timestamp",
"equal",
"to",
"the",
"max",
"timestamp",
"are",
"not",
"late"
] |
[
"public",
"rowtime",
"watermarks",
"periodic",
"ascending",
"(",
")",
"{",
"internal",
"properties",
"put",
"string",
"(",
"rowtime",
"watermarks",
"type",
",",
"rowtime",
"watermarks",
"type",
"value",
"periodic",
"ascending",
")",
";",
"return",
"this",
";",
"}"
] |
[
"creates",
"the",
"feature",
"configuration",
"for",
"a",
"given",
"rule"
] |
[
"public",
"static",
"feature",
"configuration",
"configure",
"features",
"or",
"report",
"rule",
"error",
"(",
"rule",
"context",
"rule",
"context",
",",
"immutable",
"set",
"<",
"string",
">",
"requested",
"features",
",",
"immutable",
"set",
"<",
"string",
">",
"unsupported",
"features",
",",
"cc",
"toolchain",
"provider",
"toolchain",
",",
"cpp",
"semantics",
"cpp",
"semantics",
")",
"{",
"cpp",
"semantics",
"validate",
"layering",
"check",
"features",
"(",
"rule",
"context",
",",
"/",
"*",
"aspect",
"descriptor",
"=",
"*",
"/",
"null",
",",
"toolchain",
",",
"immutable",
"set",
"of",
"(",
")",
")",
";",
"try",
"{",
"return",
"configure",
"features",
"or",
"throw",
"eval",
"exception",
"(",
"requested",
"features",
",",
"unsupported",
"features",
",",
"toolchain",
",",
"rule",
"context",
"get",
"fragment",
"(",
"cpp",
"configuration",
"class",
")",
")",
";",
"}",
"catch",
"(",
"eval",
"exception",
"e",
")",
"{",
"rule",
"context",
"rule",
"error",
"(",
"e",
"get",
"message",
"(",
")",
")",
";",
"return",
"feature",
"configuration",
"empty",
";",
"}",
"}"
] |
[
"write",
"objects",
"to",
"the",
"os"
] |
[
"protected",
"final",
"int",
"do",
"write",
"0",
"(",
"channel",
"outbound",
"buffer",
"in",
")",
"throws",
"exception",
"{",
"object",
"msg",
"=",
"in",
"current",
"(",
")",
";",
"if",
"(",
"msg",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"directly",
"return",
"here",
"so",
"incomplete",
"write",
"(",
")",
"is",
"not",
"called",
"return",
"0",
";",
"}",
"return",
"do",
"write",
"internal",
"(",
"in",
",",
"in",
"current",
"(",
")",
")",
";",
"}"
] |
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
] |
[
"private",
"string",
"to",
"indented",
"string",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"fallback",
"to",
"clear",
"text",
"passwords",
"in",
"configuration"
] |
[
"protected",
"char",
"[",
"]",
"get",
"password",
"from",
"config",
"(",
"string",
"name",
")",
"{",
"char",
"[",
"]",
"pass",
"=",
"null",
";",
"if",
"(",
"get",
"boolean",
"(",
"credential",
"provider",
"clear",
"text",
"fallback",
",",
"true",
")",
")",
"{",
"string",
"pass",
"str",
"=",
"get",
"(",
"name",
")",
";",
"if",
"(",
"pass",
"str",
"!",
"=",
"null",
")",
"{",
"pass",
"=",
"pass",
"str",
"to",
"char",
"array",
"(",
")",
";",
"}",
"}",
"return",
"pass",
";",
"}"
] |
[
"helper",
"method",
"for",
"{",
"@",
"link",
"#",
"check",
"constraints",
"}",
":",
"refines",
"a",
"rule",
"'",
"s",
"environments",
"with",
"the",
"given",
"dep",
"a",
"rule",
"'",
"s",
"<",
"b",
">",
"complete",
"<",
"b",
">",
"refined",
"set",
"applies",
"this",
"process",
"to",
"every",
"dep"
] |
[
"private",
"static",
"void",
"refine",
"environments",
"for",
"dep",
"(",
"rule",
"context",
"rule",
"context",
",",
"environment",
"collection",
"static",
"environments",
",",
"transitive",
"info",
"collection",
"dep",
",",
"map",
"<",
"label",
",",
"environment",
"with",
"group",
">",
"labels",
"to",
"environments",
",",
"set",
"<",
"environment",
"with",
"group",
">",
"refined",
"environments",
"so",
"far",
",",
"set",
"<",
"environment",
"labels",
">",
"groups",
"with",
"environments",
"removed",
",",
"map",
"<",
"label",
",",
"removed",
"environment",
"culprit",
">",
"removed",
"environment",
"culprits",
")",
"{",
"supported",
"environments",
"provider",
"dep",
"environments",
"=",
"dep",
"get",
"provider",
"(",
"supported",
"environments",
"provider",
"class",
")",
";",
"/",
"/",
"stores",
"the",
"environments",
"that",
"are",
"pruned",
"from",
"the",
"refined",
"set",
"because",
"of",
"this",
"dep",
"even",
"/",
"/",
"though",
"they",
"'",
"re",
"removed",
",",
"some",
"subset",
"of",
"the",
"environments",
"they",
"fulfill",
"may",
"belong",
"in",
"the",
"/",
"/",
"refined",
"set",
"for",
"example",
",",
"if",
"environment",
"\"",
"both",
"\"",
"fulfills",
"\"",
"a",
"\"",
"and",
"\"",
"b",
"\"",
"and",
"\"",
"lib",
"\"",
"statically",
"/",
"/",
"sets",
"restricted",
"to",
"=",
"[",
"\"",
"both",
"\"",
"]",
"and",
"\"",
"dep",
"\"",
"sets",
"restricted",
"to",
"=",
"[",
"\"",
"a",
"\"",
"]",
",",
"then",
"lib",
"'",
"s",
"refined",
"set",
"/",
"/",
"excludes",
"\"",
"both",
"\"",
"but",
"rather",
"than",
"be",
"emptied",
"out",
"it",
"can",
"be",
"reduced",
"to",
"\"",
"a",
"\"",
"set",
"<",
"label",
">",
"pruned",
"environments",
"from",
"this",
"dep",
"=",
"new",
"linked",
"hash",
"set",
"<",
">",
"(",
")",
";",
"/",
"/",
"refine",
"this",
"rule",
"'",
"s",
"environments",
"by",
"intersecting",
"with",
"the",
"dep",
"'",
"s",
"refined",
"environments",
":",
"for",
"(",
"label",
"refined",
"environment",
"to",
"prune",
":",
"get",
"unsupported",
"environments",
"(",
"dep",
"environments",
"get",
"refined",
"environments",
"(",
")",
",",
"static",
"environments",
")",
")",
"{",
"environment",
"with",
"group",
"env",
"to",
"prune",
"=",
"labels",
"to",
"environments",
"get",
"(",
"refined",
"environment",
"to",
"prune",
")",
";",
"if",
"(",
"env",
"to",
"prune",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"if",
"we",
"have",
"no",
"record",
"of",
"this",
"environment",
",",
"that",
"means",
"the",
"current",
"rule",
"implicitly",
"uses",
"/",
"/",
"the",
"defaults",
"for",
"this",
"group",
"so",
"explicitly",
"opt",
"that",
"group",
"'",
"s",
"defaults",
"into",
"the",
"refined",
"/",
"/",
"set",
"before",
"trying",
"to",
"remove",
"specific",
"items",
"for",
"(",
"environment",
"with",
"group",
"default",
"env",
":",
"get",
"defaults",
"(",
"refined",
"environment",
"to",
"prune",
",",
"dep",
"environments",
"get",
"refined",
"environments",
"(",
")",
")",
")",
"{",
"refined",
"environments",
"so",
"far",
"add",
"(",
"default",
"env",
")",
";",
"labels",
"to",
"environments",
"put",
"(",
"default",
"env",
"environment",
"(",
")",
",",
"default",
"env",
")",
";",
"}",
"env",
"to",
"prune",
"=",
"verify",
"verify",
"not",
"null",
"(",
"labels",
"to",
"environments",
"get",
"(",
"refined",
"environment",
"to",
"prune",
")",
")",
";",
"}",
"refined",
"environments",
"so",
"far",
"remove",
"(",
"env",
"to",
"prune",
")",
";",
"groups",
"with",
"environments",
"removed",
"add",
"(",
"env",
"to",
"prune",
"group",
"(",
")",
")",
";",
"removed",
"environment",
"culprits",
"put",
"(",
"env",
"to",
"prune",
"environment",
"(",
")",
",",
"find",
"original",
"refiner",
"(",
"rule",
"context",
",",
"dep",
"get",
"label",
"(",
")",
",",
"dep",
"environments",
",",
"env",
"to",
"prune",
")",
")",
";",
"pruned",
"environments",
"from",
"this",
"dep",
"add",
"(",
"env",
"to",
"prune",
"environment",
"(",
")",
")",
";",
"}",
"/",
"/",
"add",
"in",
"any",
"dep",
"environment",
"that",
"one",
"of",
"the",
"environments",
"we",
"removed",
"fulfills",
"in",
"other",
"/",
"/",
"words",
",",
"the",
"removed",
"environment",
"is",
"no",
"good",
",",
"but",
"some",
"subset",
"of",
"it",
"may",
"be",
"for",
"(",
"environment",
"with",
"group",
"dep",
"env",
":",
"dep",
"environments",
"get",
"refined",
"environments",
"(",
")",
"get",
"grouped",
"environments",
"(",
")",
")",
"{",
"for",
"(",
"label",
"fulfiller",
":",
"dep",
"env",
"group",
"(",
")",
"get",
"fulfillers",
"(",
"dep",
"env",
"environment",
"(",
")",
")",
"to",
"list",
"(",
")",
")",
"{",
"if",
"(",
"pruned",
"environments",
"from",
"this",
"dep",
"contains",
"(",
"fulfiller",
")",
")",
"{",
"refined",
"environments",
"so",
"far",
"add",
"(",
"dep",
"env",
")",
";",
"}",
"}",
"}",
"}"
] |
[
"return",
"a",
"future",
"which",
"succeeds",
"only",
"if",
"all",
"the",
"config",
"descriptions",
"succeed"
] |
[
"public",
"kafka",
"future",
"<",
"map",
"<",
"config",
"resource",
",",
"config",
">",
">",
"all",
"(",
")",
"{",
"return",
"kafka",
"future",
"all",
"of",
"(",
"futures",
"values",
"(",
")",
"to",
"array",
"(",
"new",
"kafka",
"future",
"[",
"0",
"]",
")",
")",
"then",
"apply",
"(",
"new",
"kafka",
"future",
"base",
"function",
"<",
"void",
",",
"map",
"<",
"config",
"resource",
",",
"config",
">",
">",
"(",
")",
"{",
"@",
"override",
"public",
"map",
"<",
"config",
"resource",
",",
"config",
">",
"apply",
"(",
"void",
"v",
")",
"{",
"map",
"<",
"config",
"resource",
",",
"config",
">",
"configs",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
"futures",
"size",
"(",
")",
")",
";",
"for",
"(",
"map",
"entry",
"<",
"config",
"resource",
",",
"kafka",
"future",
"<",
"config",
">",
">",
"entry",
":",
"futures",
"entry",
"set",
"(",
")",
")",
"{",
"try",
"{",
"configs",
"put",
"(",
"entry",
"get",
"key",
"(",
")",
",",
"entry",
"get",
"value",
"(",
")",
"get",
"(",
")",
")",
";",
"}",
"catch",
"(",
"interrupted",
"exception",
"|",
"execution",
"exception",
"e",
")",
"{",
"/",
"/",
"this",
"should",
"be",
"unreachable",
",",
"because",
"all",
"of",
"ensured",
"that",
"all",
"the",
"futures",
"/",
"/",
"completed",
"successfully",
"throw",
"new",
"runtime",
"exception",
"(",
"e",
")",
";",
"}",
"}",
"return",
"configs",
";",
"}",
"}",
")",
";",
"}"
] |
[
"build",
"a",
"{",
"@",
"link",
"s",
"3",
"a",
"located",
"file",
"status",
"}",
"from",
"a",
"{",
"@",
"link",
"file",
"status",
"}",
"instance"
] |
[
"s",
"3",
"a",
"located",
"file",
"status",
"to",
"located",
"file",
"status",
"(",
"s",
"3",
"a",
"file",
"status",
"status",
")",
"throws",
"i",
"o",
"exception",
";"
] |
[
"test",
"access",
"when",
"requested",
"permissions",
"do",
"not",
"match",
"existing",
"permissions"
] |
[
"public",
"void",
"test",
"access",
"when",
"permissions",
"do",
"not",
"match",
"(",
")",
"throws",
"throwable",
"{",
"configuration",
"conf",
"=",
"fs",
"get",
"conf",
"(",
")",
";",
"fs",
"set",
"conf",
"(",
"conf",
")",
";",
"final",
"path",
"test",
"path",
"=",
"new",
"path",
"(",
"\"",
"/",
"test",
"access",
"when",
"permissions",
"do",
"not",
"match",
"\"",
")",
";",
"authorizer",
"init",
"(",
"conf",
")",
";",
"authorizer",
"add",
"auth",
"rule",
"for",
"owner",
"(",
"\"",
"/",
"\"",
",",
"write",
",",
"true",
")",
";",
"authorizer",
"add",
"auth",
"rule",
"for",
"owner",
"(",
"test",
"path",
"to",
"string",
"(",
")",
",",
"read",
",",
"true",
")",
";",
"fs",
"update",
"wasb",
"authorizer",
"(",
"authorizer",
")",
";",
"try",
"{",
"fs",
"mkdirs",
"(",
"test",
"path",
")",
";",
"assert",
"path",
"exists",
"(",
"fs",
",",
"\"",
"test",
"path",
"does",
"not",
"exist",
"\"",
",",
"test",
"path",
")",
";",
"assert",
"no",
"access",
"(",
"test",
"path",
",",
"fs",
"action",
"all",
")",
";",
"assert",
"no",
"access",
"(",
"test",
"path",
",",
"fs",
"action",
"write",
")",
";",
"assert",
"no",
"access",
"(",
"test",
"path",
",",
"fs",
"action",
"write",
"execute",
")",
";",
"}",
"finally",
"{",
"recursive",
"delete",
"(",
"test",
"path",
")",
";",
"}",
"}"
] |
[
"constructs",
"an",
"event",
"with",
"kind",
"{",
"@",
"link",
"event",
"kind",
"#",
"fatal",
"}"
] |
[
"public",
"static",
"event",
"fatal",
"(",
"string",
"message",
")",
"{",
"return",
"of",
"(",
"event",
"kind",
"fatal",
",",
"message",
")",
";",
"}"
] |
[
"one",
"constant",
"only",
"matters",
"now",
"since",
"it",
"can",
"be",
"either",
"null",
"or",
"the",
"constant"
] |
[
"public",
"static",
"object",
"bad",
"(",
"string",
"a",
",",
"int",
"b",
",",
"@",
"nullable",
"decl",
"one",
"constant",
"enum",
"one",
"constant",
"only",
")",
"{",
"return",
"new",
"good",
"equals",
"(",
"a",
",",
"b",
")",
";",
"}"
] |
[
"get",
"attribute",
"boolean"
] |
[
"public",
"boolean",
"get",
"attribute",
"boolean",
"(",
")",
"{",
"return",
"attribute",
"boolean",
";",
"}"
] |
[
"sets",
"flags",
"for",
"{",
"@",
"link",
"flac",
"extractor",
"}",
"instances",
"created",
"by",
"the",
"factory",
"the",
"flags",
"are",
"also",
"used",
"by",
"{",
"@",
"code",
"com",
"google",
"android",
"exoplayer",
"2",
"ext",
"flac",
"flac",
"extractor",
"}",
"instances",
"if",
"the",
"flac",
"extension",
"is",
"being",
"used"
] |
[
"public",
"synchronized",
"default",
"extractors",
"factory",
"set",
"flac",
"extractor",
"flags",
"(",
"@",
"flac",
"extractor",
"flags",
"int",
"flags",
")",
"{",
"this",
"flac",
"flags",
"=",
"flags",
";",
"return",
"this",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"password",
"'"
] |
[
"public",
"void",
"password",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"password",
"}"
] |
[
"remove",
"the",
"given",
"file",
"upload",
"from",
"the",
"list",
"of",
"file",
"uploads",
"to",
"clean"
] |
[
"public",
"void",
"remove",
"http",
"data",
"from",
"clean",
"(",
"interface",
"http",
"data",
"data",
")",
"{",
"check",
"destroyed",
"(",
")",
";",
"factory",
"remove",
"http",
"data",
"from",
"clean",
"(",
"request",
",",
"data",
")",
";",
"}"
] |
[
"if",
"an",
"initial",
"state",
"for",
"this",
"component",
"has",
"already",
"been",
"created",
"just",
"transfers",
"it",
"to",
"it",
"otherwise",
"on",
"create",
"initial",
"state",
"gets",
"called",
"for",
"the",
"component",
"and",
"its",
"result",
"cached"
] |
[
"void",
"create",
"or",
"get",
"initial",
"state",
"for",
"component",
"(",
"component",
"component",
",",
"component",
"context",
"scoped",
"context",
")",
"{",
"object",
"state",
"lock",
";",
"synchronized",
"(",
"this",
")",
"{",
"state",
"lock",
"=",
"m",
"create",
"initial",
"state",
"locks",
"get",
"(",
"component",
"get",
"global",
"key",
"(",
"scoped",
"context",
",",
"component",
")",
")",
";",
"if",
"(",
"state",
"lock",
"=",
"=",
"null",
")",
"{",
"state",
"lock",
"=",
"new",
"object",
"(",
")",
";",
"m",
"create",
"initial",
"state",
"locks",
"put",
"(",
"component",
"get",
"global",
"key",
"(",
"scoped",
"context",
",",
"component",
")",
",",
"state",
"lock",
")",
";",
"}",
"}",
"synchronized",
"(",
"state",
"lock",
")",
"{",
"final",
"state",
"container",
"state",
"container",
"=",
"m",
"initial",
"states",
"get",
"(",
"component",
"get",
"global",
"key",
"(",
"scoped",
"context",
",",
"component",
")",
")",
";",
"if",
"(",
"state",
"container",
"=",
"=",
"null",
")",
"{",
"component",
"create",
"initial",
"state",
"(",
"scoped",
"context",
")",
";",
"m",
"initial",
"states",
"put",
"(",
"component",
"get",
"global",
"key",
"(",
"scoped",
"context",
",",
"component",
")",
",",
"component",
"get",
"state",
"container",
"(",
"scoped",
"context",
")",
")",
";",
"}",
"else",
"{",
"component",
"transfer",
"state",
"(",
"state",
"container",
",",
"component",
"get",
"state",
"container",
"(",
"scoped",
"context",
")",
")",
";",
"}",
"}",
"}"
] |
[
"test",
"the",
"property",
"'",
"name",
"'"
] |
[
"public",
"void",
"name",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"name",
"}"
] |
[
"configure",
"the",
"description",
"for",
"the",
"action",
"this",
"description",
"will",
"appear",
"as",
"a",
"tooltip",
"over",
"tool",
"bar",
"buttons"
] |
[
"public",
"b",
"description",
"(",
"string",
"text",
")",
"{",
"this",
"description",
"=",
"text",
";",
"return",
"self",
"(",
")",
";",
"}"
] |
[
"write",
"a",
"{",
"@",
"link",
"time",
"value",
"}",
"to",
"the",
"stream"
] |
[
"public",
"void",
"write",
"time",
"value",
"(",
"time",
"value",
"time",
"value",
")",
"throws",
"i",
"o",
"exception",
"{",
"write",
"z",
"long",
"(",
"time",
"value",
"duration",
"(",
")",
")",
";",
"write",
"byte",
"(",
"(",
"byte",
")",
"time",
"value",
"time",
"unit",
"(",
")",
"ordinal",
"(",
")",
")",
";",
"}"
] |
[
"returns",
"the",
"{",
"@",
"link",
"mp",
"4a",
"object",
"type",
"}",
"of",
"an",
"rfc",
"6381",
"mp4",
"audio",
"codec",
"string",
"per",
"https",
":",
"mp",
"4ra",
"org",
"#",
"object",
"types",
"and",
"https",
":",
"tools",
"ietf",
"orghtmlrfc",
"6",
"3",
"8",
"1",
"#",
"section",
"-",
"3",
"3",
",",
"an",
"mp4",
"codec",
"string",
"has",
"the",
"form",
":",
"~",
"~",
"~",
"~",
"~",
"~",
"~",
"~",
"~",
"~",
"~",
"~",
"~",
"~",
"object",
"type",
"indication",
"(",
"oti",
")",
"byte",
"in",
"hex",
"mp",
"4a",
"[",
"a",
"-",
"z",
"a",
"-",
"z0",
"-",
"9",
"]",
"{",
"2",
"}",
"(",
"[",
"0",
"-",
"9",
"]",
"{",
"1",
",",
"2",
"}",
")",
"?",
"~",
"~",
"~",
"~",
"~",
"~",
"~",
"~",
"~",
"~",
"audio",
"oti",
",",
"decimal",
"only",
"for",
"certain",
"oti",
"for",
"example",
",",
"mp",
"4a",
"40",
"2",
"has",
"an",
"oti",
"of",
"0x",
"4",
"0",
"and",
"an",
"audio",
"oti",
"of",
"2"
] |
[
"/",
"*",
"package",
"*",
"/",
"static",
"mp",
"4a",
"object",
"type",
"get",
"object",
"type",
"from",
"mp",
"4a",
"r",
"f",
"c",
"6",
"3",
"8",
"1",
"codec",
"string",
"(",
"string",
"codec",
")",
"{",
"matcher",
"matcher",
"=",
"mp4a",
"rfc",
"6381",
"codec",
"pattern",
"matcher",
"(",
"codec",
")",
";",
"if",
"(",
"!",
"matcher",
"matches",
"(",
")",
")",
"{",
"return",
"null",
";",
"}",
"string",
"object",
"type",
"indication",
"hex",
"=",
"assertions",
"check",
"not",
"null",
"(",
"matcher",
"group",
"(",
"1",
")",
")",
";",
"@",
"nullable",
"string",
"audio",
"object",
"type",
"indication",
"dec",
"=",
"matcher",
"group",
"(",
"2",
")",
";",
"int",
"object",
"type",
"indication",
";",
"int",
"audio",
"object",
"type",
"indication",
"=",
"0",
";",
"try",
"{",
"object",
"type",
"indication",
"=",
"integer",
"parse",
"int",
"(",
"object",
"type",
"indication",
"hex",
",",
"16",
")",
";",
"if",
"(",
"audio",
"object",
"type",
"indication",
"dec",
"!",
"=",
"null",
")",
"{",
"audio",
"object",
"type",
"indication",
"=",
"integer",
"parse",
"int",
"(",
"audio",
"object",
"type",
"indication",
"dec",
")",
";",
"}",
"}",
"catch",
"(",
"number",
"format",
"exception",
"e",
")",
"{",
"return",
"null",
";",
"}",
"return",
"new",
"mp",
"4a",
"object",
"type",
"(",
"object",
"type",
"indication",
",",
"audio",
"object",
"type",
"indication",
")",
";",
"}"
] |
[
"appends",
"the",
"least",
"-",
"significant",
"bits",
",",
"from",
"value",
",",
"in",
"order",
"from",
"most",
"-",
"significant",
"to",
"least",
"-",
"significant",
"for",
"example",
",",
"appending",
"6",
"bits",
"from",
"0x",
"0",
"0",
"0",
"0",
"0",
"1",
"e",
"will",
"append",
"the",
"bits",
"0",
",",
"1",
",",
"1",
",",
"1",
",",
"1",
",",
"0",
"in",
"that",
"order"
] |
[
"public",
"void",
"append",
"bits",
"(",
"int",
"value",
",",
"int",
"num",
"bits",
")",
"{",
"if",
"(",
"num",
"bits",
"<",
"0",
"|",
"|",
"num",
"bits",
">",
"32",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"num",
"bits",
"must",
"be",
"between",
"0",
"and",
"32",
"\"",
")",
";",
"}",
"ensure",
"capacity",
"(",
"size",
"+",
"num",
"bits",
")",
";",
"for",
"(",
"int",
"num",
"bits",
"left",
"=",
"num",
"bits",
";",
"num",
"bits",
"left",
">",
"0",
";",
"num",
"bits",
"left",
"-",
"-",
")",
"{",
"append",
"bit",
"(",
"(",
"(",
"value",
">",
">",
"(",
"num",
"bits",
"left",
"-",
"1",
")",
")",
"&",
"0x",
"0",
"1",
")",
"=",
"=",
"1",
")",
";",
"}",
"}"
] |
[
"validates",
"that",
"the",
"component",
"instances",
"that",
"are",
"requested",
"to",
"upgrade",
"require",
"an",
"upgrade"
] |
[
"public",
"static",
"void",
"validate",
"instances",
"upgrade",
"(",
"list",
"<",
"container",
">",
"live",
"containers",
")",
"throws",
"yarn",
"exception",
"{",
"for",
"(",
"container",
"live",
"container",
":",
"live",
"containers",
")",
"{",
"if",
"(",
"!",
"is",
"upgradable",
"(",
"live",
"container",
")",
")",
"{",
"/",
"/",
"nothing",
"to",
"upgrade",
"throw",
"new",
"yarn",
"exception",
"(",
"string",
"format",
"(",
"error",
"comp",
"instance",
"does",
"not",
"need",
"upgrade",
",",
"live",
"container",
"get",
"component",
"instance",
"name",
"(",
")",
")",
")",
";",
"}",
"}",
"}"
] |
[
"creates",
"a",
"new",
"server",
"-",
"side",
"{",
"@",
"link",
"ssl",
"context",
"}"
] |
[
"public",
"static",
"ssl",
"context",
"new",
"server",
"context",
"(",
"ssl",
"provider",
"provider",
",",
"file",
"trust",
"cert",
"collection",
"file",
",",
"trust",
"manager",
"factory",
"trust",
"manager",
"factory",
",",
"file",
"key",
"cert",
"chain",
"file",
",",
"file",
"key",
"file",
",",
"string",
"key",
"password",
",",
"key",
"manager",
"factory",
"key",
"manager",
"factory",
",",
"iterable",
"<",
"string",
">",
"ciphers",
",",
"cipher",
"suite",
"filter",
"cipher",
"filter",
",",
"application",
"protocol",
"config",
"apn",
",",
"long",
"session",
"cache",
"size",
",",
"long",
"session",
"timeout",
")",
"throws",
"s",
"s",
"l",
"exception",
"{",
"return",
"new",
"server",
"context",
"(",
"provider",
",",
"trust",
"cert",
"collection",
"file",
",",
"trust",
"manager",
"factory",
",",
"key",
"cert",
"chain",
"file",
",",
"key",
"file",
",",
"key",
"password",
",",
"key",
"manager",
"factory",
",",
"ciphers",
",",
"cipher",
"filter",
",",
"apn",
",",
"session",
"cache",
"size",
",",
"session",
"timeout",
",",
"key",
"store",
"get",
"default",
"type",
"(",
")",
")",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.