docstring_tokens
list | code_tokens
list |
|---|---|
[
"validate",
"the",
"arguments",
"to",
"{",
"@",
"link",
"path",
"capabilities",
"#",
"has",
"path",
"capability",
"(",
"path",
",",
"string",
")",
"}"
]
| [
"public",
"static",
"string",
"validate",
"path",
"capability",
"args",
"(",
"final",
"path",
"path",
",",
"final",
"string",
"capability",
")",
"{",
"check",
"argument",
"(",
"path",
"!",
"=",
"null",
",",
"\"",
"null",
"path",
"\"",
")",
";",
"check",
"argument",
"(",
"capability",
"!",
"=",
"null",
",",
"\"",
"capability",
"parameter",
"is",
"null",
"\"",
")",
";",
"check",
"argument",
"(",
"!",
"capability",
"is",
"empty",
"(",
")",
",",
"\"",
"capability",
"parameter",
"is",
"empty",
"string",
"\"",
")",
";",
"return",
"capability",
"to",
"lower",
"case",
"(",
"locale",
"english",
")",
";",
"}"
]
|
[
"provides",
"the",
"credentials",
"that",
"are",
"used",
"to",
"assume",
"the",
"role"
]
| [
"public",
"role",
"info",
"with",
"long",
"lived",
"credentials",
"provider",
"(",
"a",
"w",
"s",
"credentials",
"provider",
"long",
"lived",
"credentials",
"provider",
")",
"{",
"set",
"long",
"lived",
"credentials",
"provider",
"(",
"long",
"lived",
"credentials",
"provider",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"get",
"the",
"length",
"of",
"the",
"instruction",
"encoding",
"this",
"is",
"used",
"to",
"ensure",
"each",
"operand",
"is",
"encoded",
"at",
"the",
"correct",
"offset"
]
| [
"public",
"int",
"get",
"instruction",
"length",
"(",
")",
"{",
"int",
"inslen",
"=",
"ins",
"length",
"(",
")",
";",
"for",
"(",
"assembly",
"resolved",
"backfill",
"bf",
":",
"backfills",
")",
"{",
"inslen",
"=",
"math",
"max",
"(",
"inslen",
",",
"bf",
"get",
"instruction",
"length",
"(",
")",
")",
";",
"}",
"return",
"inslen",
";",
"}"
]
|
[
"returns",
"true",
"if",
"n",
"-",
"th",
"bit",
"is",
"on"
]
| [
"private",
"boolean",
"check",
"bits",
"(",
"long",
"bit",
"mask",
",",
"int",
"n",
")",
"{",
"return",
"(",
"bit",
"mask",
"|",
"(",
"1l",
"<",
"<",
"n",
")",
")",
"=",
"=",
"bit",
"mask",
";",
"}"
]
|
[
"validation",
"of",
"the",
"display",
"name",
"field"
]
| [
"protected",
"form",
"validation",
"check",
"display",
"name",
"(",
"@",
"non",
"null",
"view",
"view",
",",
"@",
"check",
"for",
"null",
"string",
"value",
")",
"{",
"if",
"(",
"string",
"utils",
"is",
"blank",
"(",
"value",
")",
")",
"{",
"/",
"/",
"no",
"custom",
"name",
",",
"no",
"need",
"to",
"check",
"return",
"form",
"validation",
"ok",
"(",
")",
";",
"}",
"for",
"(",
"view",
"v",
":",
"view",
"owner",
"get",
"views",
"(",
")",
")",
"{",
"if",
"(",
"v",
"get",
"view",
"name",
"(",
")",
"equals",
"(",
"view",
"get",
"view",
"name",
"(",
")",
")",
")",
"{",
"continue",
";",
"}",
"if",
"(",
"string",
"utils",
"equals",
"(",
"v",
"get",
"display",
"name",
"(",
")",
",",
"value",
")",
")",
"{",
"return",
"form",
"validation",
"warning",
"(",
"messages",
"view",
"display",
"name",
"not",
"unique",
"warning",
"(",
"value",
")",
")",
";",
"}",
"}",
"return",
"form",
"validation",
"ok",
"(",
")",
";",
"}"
]
|
[
"returns",
"list",
"of",
"unique",
"registers",
"which",
"do",
"not",
"overlap",
"any",
"smaller",
"registers"
]
| [
"private",
"list",
"<",
"register",
">",
"get",
"unique",
"registers",
"(",
")",
"{",
"array",
"list",
"<",
"register",
">",
"regs",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"context",
"get",
"registers",
"(",
")",
")",
";",
"collections",
"sort",
"(",
"regs",
",",
"new",
"comparator",
"<",
"register",
">",
"(",
")",
"{",
"@",
"override",
"public",
"int",
"compare",
"(",
"register",
"r",
"1",
",",
"register",
"r",
"2",
")",
"{",
"int",
"size",
"1",
"=",
"r",
"1",
"get",
"minimum",
"byte",
"size",
"(",
")",
";",
"int",
"size",
"2",
"=",
"r",
"2",
"get",
"minimum",
"byte",
"size",
"(",
")",
";",
"if",
"(",
"size",
"1",
"!",
"=",
"size",
"2",
")",
"{",
"return",
"size",
"1",
"-",
"size",
"2",
";",
"}",
"return",
"r",
"1",
"get",
"offset",
"(",
")",
"-",
"r",
"2",
"get",
"offset",
"(",
")",
";",
"}",
"}",
")",
";",
"return",
"regs",
";",
"}"
]
|
[
"apply",
"pdb",
"debug",
"information",
"to",
"the",
"current",
"program"
]
| [
"public",
"void",
"apply",
"to",
"(",
"message",
"log",
"log",
")",
"throws",
"i",
"o",
"exception",
",",
"pdb",
"exception",
",",
"cancelled",
"exception",
"{",
"if",
"(",
"!",
"parsed",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"pdb",
":",
"parse",
"(",
")",
"must",
"be",
"called",
"before",
"apply",
"to",
"(",
")",
"\"",
")",
";",
"}",
"check",
"pdb",
"loaded",
"(",
")",
";",
"err",
"handler",
"set",
"message",
"log",
"(",
"log",
")",
";",
"msg",
"debug",
"(",
"this",
",",
"\"",
"found",
"pdb",
"for",
"\"",
"+",
"program",
"get",
"name",
"(",
")",
"+",
"\"",
":",
"\"",
"+",
"pdb",
"file",
")",
";",
"try",
"{",
"apply",
"data",
"types",
"apply",
"data",
"types",
"=",
"null",
";",
"apply",
"type",
"defs",
"apply",
"type",
"defs",
"=",
"null",
";",
"boolean",
"types",
"flushed",
"=",
"false",
";",
"while",
"(",
"parser",
"has",
"next",
"(",
")",
")",
"{",
"if",
"(",
"has",
"errors",
"(",
")",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"get",
"error",
"and",
"warning",
"messages",
"(",
")",
")",
";",
"}",
"monitor",
"check",
"canceled",
"(",
")",
";",
"xml",
"element",
"element",
"=",
"parser",
"next",
"(",
")",
";",
"if",
"(",
"!",
"element",
"is",
"start",
"(",
")",
")",
"{",
"continue",
";",
"}",
"/",
"/",
"long",
"start",
"=",
"system",
"current",
"time",
"millis",
"(",
")",
";",
"if",
"(",
"element",
"get",
"name",
"(",
")",
"equals",
"(",
"\"",
"pdb",
"\"",
")",
")",
"{",
"/",
"*",
"string",
"exe",
"=",
"element",
"get",
"attribute",
"(",
"\"",
"exe",
"\"",
")",
";",
"exe",
"=",
"(",
"exe",
"=",
"=",
"null",
"?",
"\"",
"\"",
":",
"exe",
"to",
"lower",
"case",
"(",
")",
")",
";",
"file",
"exe",
"file",
"=",
"new",
"file",
"(",
"program",
"get",
"executable",
"path",
"(",
")",
")",
";",
"if",
"(",
"!",
"exe",
"file",
"get",
"name",
"(",
")",
"to",
"lower",
"case",
"(",
")",
"starts",
"with",
"(",
"exe",
")",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"'",
"\"",
"+",
"pdb",
"file",
"get",
"name",
"(",
")",
"+",
"\"",
"'",
"not",
"valid",
"for",
"'",
"\"",
"+",
"exe",
"file",
"get",
"name",
"(",
")",
"+",
"\"",
"'",
"\"",
")",
";",
"}",
"*",
"/",
"}",
"else",
"if",
"(",
"element",
"get",
"name",
"(",
")",
"equals",
"(",
"\"",
"enums",
"\"",
")",
")",
"{",
"/",
"/",
"apply",
"enums",
"-",
"no",
"data",
"type",
"dependencies",
"apply",
"enums",
"apply",
"to",
"(",
"parser",
",",
"this",
",",
"monitor",
",",
"log",
")",
";",
"}",
"else",
"if",
"(",
"element",
"get",
"name",
"(",
")",
"equals",
"(",
"\"",
"datatypes",
"\"",
")",
")",
"{",
"if",
"(",
"apply",
"data",
"types",
"=",
"=",
"null",
")",
"{",
"apply",
"data",
"types",
"=",
"new",
"apply",
"data",
"types",
"(",
"this",
",",
"log",
")",
";",
"}",
"apply",
"data",
"types",
"pre",
"process",
"data",
"type",
"list",
"(",
"parser",
",",
"false",
",",
"monitor",
")",
";",
"}",
"else",
"if",
"(",
"element",
"get",
"name",
"(",
")",
"equals",
"(",
"\"",
"classes",
"\"",
")",
")",
"{",
"if",
"(",
"apply",
"data",
"types",
"=",
"=",
"null",
")",
"{",
"apply",
"data",
"types",
"=",
"new",
"apply",
"data",
"types",
"(",
"this",
",",
"log",
")",
";",
"}",
"apply",
"data",
"types",
"pre",
"process",
"data",
"type",
"list",
"(",
"parser",
",",
"true",
",",
"monitor",
")",
";",
"}",
"else",
"if",
"(",
"element",
"get",
"name",
"(",
")",
"equals",
"(",
"\"",
"typedefs",
"\"",
")",
")",
"{",
"apply",
"type",
"defs",
"=",
"new",
"apply",
"type",
"defs",
"(",
"this",
",",
"parser",
",",
"monitor",
",",
"log",
")",
";",
"}",
"else",
"if",
"(",
"element",
"get",
"name",
"(",
")",
"equals",
"(",
"\"",
"functions",
"\"",
")",
")",
"{",
"/",
"/",
"apply",
"functions",
"(",
"must",
"occur",
"within",
"xml",
"after",
"all",
"type",
"sections",
")",
"if",
"(",
"!",
"types",
"flushed",
")",
"{",
"complete",
"deffered",
"type",
"parsing",
"(",
"apply",
"data",
"types",
",",
"apply",
"type",
"defs",
",",
"log",
")",
";",
"types",
"flushed",
"=",
"true",
";",
"}",
"apply",
"functions",
"apply",
"to",
"(",
"this",
",",
"parser",
",",
"monitor",
",",
"log",
")",
";",
"}",
"else",
"if",
"(",
"element",
"get",
"name",
"(",
")",
"equals",
"(",
"\"",
"tables",
"\"",
")",
")",
"{",
"/",
"/",
"apply",
"tables",
"(",
"must",
"occur",
"within",
"xml",
"after",
"all",
"other",
"sections",
")",
"if",
"(",
"!",
"types",
"flushed",
")",
"{",
"complete",
"deffered",
"type",
"parsing",
"(",
"apply",
"data",
"types",
",",
"apply",
"type",
"defs",
",",
"log",
")",
";",
"types",
"flushed",
"=",
"true",
";",
"}",
"apply",
"tables",
"apply",
"to",
"(",
"this",
",",
"parser",
",",
"monitor",
",",
"log",
")",
";",
"}",
"/",
"/",
"msg",
"debug",
"(",
"this",
",",
"/",
"/",
"element",
"get",
"name",
"(",
")",
"to",
"upper",
"case",
"(",
")",
"+",
"\"",
":",
"\"",
"+",
"(",
"system",
"current",
"time",
"millis",
"(",
")",
"-",
"start",
")",
"+",
"/",
"/",
"\"",
"ms",
"\"",
")",
";",
"}",
"if",
"(",
"!",
"types",
"flushed",
")",
"{",
"complete",
"deffered",
"type",
"parsing",
"(",
"apply",
"data",
"types",
",",
"apply",
"type",
"defs",
",",
"log",
")",
";",
"}",
"options",
"options",
"=",
"program",
"get",
"options",
"(",
"program",
"program",
"info",
")",
";",
"options",
"set",
"boolean",
"(",
"pdb",
"parser",
"constants",
"pdb",
"loaded",
",",
"true",
")",
";",
"if",
"(",
"data",
"type",
"parser",
"!",
"=",
"null",
"&",
"&",
"data",
"type",
"parser",
"has",
"missing",
"bit",
"offset",
"error",
"(",
")",
")",
"{",
"log",
"append",
"msg",
"(",
"\"",
"pdb",
"\"",
",",
"\"",
"one",
"or",
"more",
"bitfields",
"were",
"specified",
"without",
"bit",
"-",
"offset",
"data",
"\\",
"n",
"the",
"use",
"of",
"old",
"pdb",
"xml",
"data",
"could",
"be",
"the",
"cause",
"\"",
")",
";",
"}",
"}",
"catch",
"(",
"cancelled",
"exception",
"e",
")",
"{",
"throw",
"e",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"/",
"/",
"exception",
"could",
"occur",
"if",
"a",
"symbol",
"element",
"is",
"missing",
"an",
"important",
"attribute",
"such",
"/",
"/",
"as",
"address",
"or",
"length",
"string",
"message",
"=",
"e",
"get",
"message",
"(",
")",
";",
"if",
"(",
"message",
"=",
"=",
"null",
")",
"{",
"message",
"=",
"e",
"get",
"class",
"(",
")",
"get",
"simple",
"name",
"(",
")",
";",
"}",
"message",
"=",
"\"",
"problem",
"parsing",
"or",
"applying",
"pdb",
"information",
":",
"\"",
"+",
"message",
";",
"msg",
"error",
"(",
"this",
",",
"message",
",",
"e",
")",
";",
"throw",
"new",
"i",
"o",
"exception",
"(",
"message",
",",
"e",
")",
";",
"}",
"finally",
"{",
"cleanup",
"(",
")",
";",
"}",
"if",
"(",
"has",
"errors",
"(",
")",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"get",
"error",
"and",
"warning",
"messages",
"(",
")",
")",
";",
"}",
"}"
]
|
[
"adds",
"a",
"pattern",
"to",
"include",
"to",
"the",
"glob",
"builder",
"for",
"a",
"description",
"of",
"the",
"syntax",
"of",
"the",
"patterns",
",",
"see",
"{",
"@",
"link",
"unix",
"glob",
"}"
]
| [
"public",
"builder",
"add",
"patterns",
"(",
"string",
"patterns",
")",
"{",
"collections",
"add",
"all",
"(",
"this",
"patterns",
",",
"patterns",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"how",
"much",
"time",
"is",
"remaining",
"in",
"the",
"specified",
"time",
"unit",
"internal",
"units",
"are",
"maintained",
"as",
"nanoseconds",
"and",
"conversions",
"are",
"subject",
"to",
"the",
"constraints",
"documented",
"for",
"{",
"@",
"link",
"time",
"unit",
"#",
"convert",
"}",
"if",
"there",
"is",
"no",
"time",
"remaining",
",",
"the",
"returned",
"duration",
"is",
"how",
"long",
"ago",
"the",
"deadline",
"expired"
]
| [
"public",
"long",
"time",
"remaining",
"(",
"time",
"unit",
"unit",
")",
"{",
"final",
"long",
"now",
"nanos",
"=",
"ticker",
"nano",
"time",
"(",
")",
";",
"if",
"(",
"!",
"expired",
"&",
"&",
"deadline",
"nanos",
"-",
"now",
"nanos",
"<",
"=",
"0",
")",
"{",
"expired",
"=",
"true",
";",
"}",
"return",
"unit",
"convert",
"(",
"deadline",
"nanos",
"-",
"now",
"nanos",
",",
"time",
"unit",
"nanoseconds",
")",
";",
"}"
]
|
[
"create",
"excess",
"blocks",
"by",
"reducing",
"the",
"replication",
"factor",
"for",
"for",
"a",
"file",
"and",
"ensure",
"metrics",
"reflects",
"it"
]
| [
"public",
"void",
"test",
"excess",
"blocks",
"(",
")",
"throws",
"exception",
"{",
"path",
"file",
"=",
"get",
"test",
"path",
"(",
"\"",
"test",
"excess",
"blocks",
"\"",
")",
";",
"create",
"file",
"(",
"file",
",",
"100",
",",
"(",
"short",
")",
"2",
")",
";",
"name",
"node",
"adapter",
"set",
"replication",
"(",
"namesystem",
",",
"file",
"to",
"string",
"(",
")",
",",
"(",
"short",
")",
"1",
")",
";",
"metrics",
"record",
"builder",
"rb",
"=",
"get",
"metrics",
"(",
"ns",
"metrics",
")",
";",
"assert",
"gauge",
"(",
"\"",
"excess",
"blocks",
"\"",
",",
"1l",
",",
"rb",
")",
";",
"/",
"/",
"verify",
"excess",
"blocks",
"metric",
"is",
"decremented",
"and",
"/",
"/",
"excess",
"replicate",
"map",
"is",
"cleared",
"after",
"deleting",
"a",
"file",
"fs",
"delete",
"(",
"file",
",",
"true",
")",
";",
"rb",
"=",
"get",
"metrics",
"(",
"ns",
"metrics",
")",
";",
"assert",
"gauge",
"(",
"\"",
"excess",
"blocks",
"\"",
",",
"0l",
",",
"rb",
")",
";",
"assert",
"equals",
"(",
"0l",
",",
"bm",
"get",
"excess",
"blocks",
"count",
"(",
")",
")",
";",
"}"
]
|
[
"the",
"sequence",
"number",
"of",
"the",
"match",
"or",
"{",
"@",
"link",
"sequence",
"numbers",
"#",
"unassigned",
"seq",
"no",
"}",
"if",
"sequence",
"numbers",
"weren",
"'",
"t",
"requested"
]
| [
"long",
"get",
"seq",
"no",
"(",
")",
";"
]
|
[
"whether",
"start",
"client",
"ip",
"whitelist"
]
| [
"public",
"static",
"boolean",
"is",
"enable",
"whitelist",
"(",
")",
"{",
"return",
"is",
"open",
";",
"}"
]
|
[
"gets",
"the",
"number",
"of",
"bytes",
"of",
"all",
"written",
"data",
"(",
"including",
"the",
"metadata",
"in",
"the",
"buffer",
"headers",
")"
]
| [
"long",
"get",
"size",
"(",
")",
";"
]
|
[
"test",
"the",
"property",
"'",
"my",
"boolean",
"'"
]
| [
"public",
"void",
"my",
"boolean",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"my",
"boolean",
"}"
]
|
[
"defines",
"that",
"the",
"value",
"of",
"the",
"option",
"should",
"be",
"a",
"set",
"of",
"properties",
",",
"which",
"can",
"be",
"represented",
"as",
"{",
"@",
"code",
"map",
"<",
"string",
",",
"string",
">",
"}"
]
| [
"public",
"typed",
"config",
"option",
"builder",
"<",
"map",
"<",
"string",
",",
"string",
">",
">",
"map",
"type",
"(",
")",
"{",
"return",
"new",
"typed",
"config",
"option",
"builder",
"<",
">",
"(",
"key",
",",
"properties",
"map",
"class",
")",
";",
"}"
]
|
[
"constructs",
"a",
"hex",
"data",
"dump",
"of",
"the",
"given",
"portion",
"of",
"{",
"@",
"link",
"#",
"bytes",
"}"
]
| [
"protected",
"final",
"string",
"hex",
"dump",
"(",
"int",
"offset",
",",
"int",
"len",
")",
"{",
"return",
"hex",
"dump",
"(",
"bytes",
",",
"offset",
",",
"len",
",",
"offset",
",",
"hex",
"cols",
",",
"4",
")",
";",
"}"
]
|
[
"{",
"@",
"inherit",
"doc",
"}",
"the",
"default",
"implementation",
"does",
"nothing"
]
| [
"@",
"override",
"public",
"void",
"exit",
"decimal",
"literal",
"(",
"eql",
"base",
"parser",
"decimal",
"literal",
"context",
"ctx",
")",
"{",
"}"
]
|
[
"returns",
"a",
"string",
"containing",
"the",
"method",
"'",
"s",
"name",
"get",
"name",
"(",
")",
"returns",
"the",
"complete",
"signature",
"in",
"case",
"of",
"overloaded",
"methods",
"this",
"is",
"used",
"to",
"extract",
"only",
"the",
"name",
"of",
"the",
"method",
"e",
"g",
"ctx",
"new",
"file",
"is",
"overloaded",
"in",
"this",
"case",
"get",
"name",
"(",
")",
"returns",
"\"",
"new",
"file",
"(",
"filename",
")",
"\"",
",",
"while",
"get",
"short",
"name",
"(",
")",
"returns",
"only",
"\"",
"new",
"file",
"\""
]
| [
"public",
"string",
"get",
"short",
"name",
"(",
")",
"{",
"return",
"get",
"name",
"(",
")",
";",
"}"
]
|
[
"advances",
"to",
"the",
"next",
"batch",
"of",
"rows",
"returns",
"false",
"if",
"there",
"are",
"no",
"more"
]
| [
"private",
"boolean",
"next",
"batch",
"(",
"parquet",
"reader",
"batch",
"<",
"t",
">",
"batch",
")",
"throws",
"i",
"o",
"exception",
"{",
"for",
"(",
"writable",
"column",
"vector",
"v",
":",
"batch",
"writable",
"vectors",
")",
"{",
"v",
"reset",
"(",
")",
";",
"}",
"batch",
"columnar",
"batch",
"set",
"num",
"rows",
"(",
"0",
")",
";",
"if",
"(",
"rows",
"returned",
">",
"=",
"total",
"row",
"count",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"rows",
"returned",
"=",
"=",
"total",
"count",
"loaded",
"so",
"far",
")",
"{",
"read",
"next",
"row",
"group",
"(",
")",
";",
"}",
"int",
"num",
"=",
"(",
"int",
")",
"math",
"min",
"(",
"batch",
"size",
",",
"total",
"count",
"loaded",
"so",
"far",
"-",
"rows",
"returned",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"column",
"readers",
"length",
";",
"+",
"+",
"i",
")",
"{",
"/",
"/",
"noinspection",
"unchecked",
"column",
"readers",
"[",
"i",
"]",
"read",
"to",
"vector",
"(",
"num",
",",
"batch",
"writable",
"vectors",
"[",
"i",
"]",
")",
";",
"}",
"rows",
"returned",
"+",
"=",
"num",
";",
"batch",
"columnar",
"batch",
"set",
"num",
"rows",
"(",
"num",
")",
";",
"return",
"true",
";",
"}"
]
|
[
"get",
"namespace",
"boolean"
]
| [
"public",
"boolean",
"get",
"namespace",
"boolean",
"(",
")",
"{",
"return",
"namespace",
"boolean",
";",
"}"
]
|
[
"gets",
"x",
"5",
"0",
"9",
"c",
"r",
"l",
"from",
"attribute",
"retrieves",
"the",
"binary",
"attribute",
"value",
",",
"decodes",
"it",
"to",
"base",
"6",
"4",
",",
"and",
"fetches",
"it",
"as",
"a",
"byte",
"-",
"array",
"resource"
]
| [
"protected",
"x509crl",
"fetch",
"x",
"5",
"0",
"9",
"c",
"r",
"l",
"from",
"attribute",
"(",
"final",
"ldap",
"attribute",
"attribute",
")",
"throws",
"exception",
"{",
"if",
"(",
"attribute",
"!",
"=",
"null",
"&",
"&",
"attribute",
"is",
"binary",
"(",
")",
")",
"{",
"val",
"val",
"=",
"attribute",
"get",
"binary",
"value",
"(",
")",
";",
"if",
"(",
"val",
"=",
"=",
"null",
"|",
"|",
"val",
"length",
"=",
"=",
"0",
")",
"{",
"throw",
"new",
"certificate",
"exception",
"(",
"\"",
"empty",
"attribute",
"can",
"not",
"download",
"crl",
"from",
"ldap",
"\"",
")",
";",
"}",
"val",
"decoded",
"6",
"4",
"=",
"encoding",
"utils",
"decode",
"base",
"6",
"4",
"(",
"val",
")",
";",
"if",
"(",
"decoded",
"6",
"4",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"certificate",
"exception",
"(",
"\"",
"could",
"not",
"decode",
"the",
"attribute",
"value",
"to",
"base",
"6",
"4",
"\"",
")",
";",
"}",
"logger",
"trace",
"(",
"\"",
"retrieved",
"crl",
"from",
"ldap",
"as",
"byte",
"array",
"decoded",
"in",
"base",
"6",
"4",
"fetching",
"\"",
")",
";",
"return",
"super",
"fetch",
"(",
"new",
"byte",
"array",
"resource",
"(",
"decoded",
"6",
"4",
")",
")",
";",
"}",
"throw",
"new",
"certificate",
"exception",
"(",
"\"",
"attribute",
"not",
"found",
"can",
"not",
"retrieve",
"crl",
"\"",
")",
";",
"}"
]
|
[
"sets",
"snapshot",
"names"
]
| [
"public",
"delete",
"snapshot",
"request",
"snapshots",
"(",
"string",
"snapshots",
")",
"{",
"this",
"snapshots",
"=",
"snapshots",
";",
"return",
"this",
";",
"}"
]
|
[
"the",
"organisation",
"that",
"operates",
"the",
"service",
"provider"
]
| [
"public",
"saml",
"sp",
"metadata",
"builder",
"organization",
"(",
"string",
"org",
"name",
",",
"string",
"display",
"name",
",",
"string",
"url",
")",
"{",
"return",
"organization",
"(",
"new",
"organization",
"info",
"(",
"org",
"name",
",",
"display",
"name",
",",
"url",
")",
")",
";",
"}"
]
|
[
"if",
"true",
",",
"then",
"the",
"entry",
"points",
"should",
"be",
"readwritten"
]
| [
"public",
"boolean",
"is",
"entry",
"points",
"(",
")",
"{",
"return",
"entry",
"points",
";",
"}"
]
|
[
"this",
"returns",
"the",
"mean",
"(",
"average",
")",
"of",
"all",
"values",
"in",
"the",
"current",
"snapshot",
"this",
"is",
"not",
"a",
"percentile",
"but",
"often",
"desired",
"so",
"captured",
"and",
"exposed",
"here"
]
| [
"public",
"int",
"get",
"mean",
"(",
")",
"{",
"/",
"*",
"no",
"-",
"op",
"if",
"disabled",
"*",
"/",
"if",
"(",
"!",
"enabled",
"get",
"(",
")",
")",
"return",
"-",
"1",
";",
"/",
"/",
"force",
"logic",
"to",
"move",
"buckets",
"forward",
"in",
"case",
"other",
"requests",
"aren",
"'",
"t",
"making",
"it",
"happen",
"get",
"current",
"bucket",
"(",
")",
";",
"/",
"/",
"fetch",
"the",
"current",
"snapshot",
"return",
"get",
"current",
"percentile",
"snapshot",
"(",
")",
"get",
"mean",
"(",
")",
";",
"}"
]
|
[
"if",
"the",
"psh",
"file",
"contains",
"a",
"line",
"starting",
"with",
"{",
"@",
"link",
"polygon",
"region",
"parameters",
"#",
"texture",
"prefix",
"params",
"texture",
"prefix",
"}",
",",
"an",
"{",
"@",
"link",
"asset",
"descriptor",
"}",
"for",
"the",
"file",
"referenced",
"on",
"that",
"line",
"will",
"be",
"added",
"to",
"the",
"returned",
"array",
"otherwise",
"a",
"sibling",
"of",
"the",
"given",
"file",
"with",
"the",
"same",
"name",
"and",
"the",
"first",
"found",
"extension",
"in",
"{",
"@",
"link",
"polygon",
"region",
"parameters",
"#",
"texture",
"extensions",
"params",
"texture",
"extensions",
"}",
"will",
"be",
"used",
"if",
"no",
"suitable",
"file",
"is",
"found",
",",
"the",
"returned",
"array",
"will",
"be",
"empty"
]
| [
"public",
"array",
"<",
"asset",
"descriptor",
">",
"get",
"dependencies",
"(",
"string",
"file",
"name",
",",
"file",
"handle",
"file",
",",
"polygon",
"region",
"parameters",
"params",
")",
"{",
"if",
"(",
"params",
"=",
"=",
"null",
")",
"params",
"=",
"default",
"parameters",
";",
"string",
"image",
"=",
"null",
";",
"try",
"{",
"buffered",
"reader",
"reader",
"=",
"file",
"reader",
"(",
"params",
"reader",
"buffer",
")",
";",
"for",
"(",
"string",
"line",
"=",
"reader",
"read",
"line",
"(",
")",
";",
"line",
"!",
"=",
"null",
";",
"line",
"=",
"reader",
"read",
"line",
"(",
")",
")",
"if",
"(",
"line",
"starts",
"with",
"(",
"params",
"texture",
"prefix",
")",
")",
"{",
"image",
"=",
"line",
"substring",
"(",
"params",
"texture",
"prefix",
"length",
"(",
")",
")",
";",
"break",
";",
"}",
"reader",
"close",
"(",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"throw",
"new",
"gdx",
"runtime",
"exception",
"(",
"\"",
"error",
"reading",
"\"",
"+",
"file",
"name",
",",
"e",
")",
";",
"}",
"if",
"(",
"image",
"=",
"=",
"null",
"&",
"&",
"params",
"texture",
"extensions",
"!",
"=",
"null",
")",
"for",
"(",
"string",
"extension",
":",
"params",
"texture",
"extensions",
")",
"{",
"file",
"handle",
"sibling",
"=",
"file",
"sibling",
"(",
"file",
"name",
"without",
"extension",
"(",
")",
"concat",
"(",
"\"",
"\"",
"+",
"extension",
")",
")",
";",
"if",
"(",
"sibling",
"exists",
"(",
")",
")",
"image",
"=",
"sibling",
"name",
"(",
")",
";",
"}",
"if",
"(",
"image",
"!",
"=",
"null",
")",
"{",
"array",
"<",
"asset",
"descriptor",
">",
"deps",
"=",
"new",
"array",
"<",
"asset",
"descriptor",
">",
"(",
"1",
")",
";",
"deps",
"add",
"(",
"new",
"asset",
"descriptor",
"<",
"texture",
">",
"(",
"file",
"sibling",
"(",
"image",
")",
",",
"texture",
"class",
")",
")",
";",
"return",
"deps",
";",
"}",
"return",
"null",
";",
"}"
]
|
[
"frees",
"an",
"object",
"from",
"the",
"{",
"@",
"link",
"#",
"get",
"(",
"class",
")",
"pool",
"}"
]
| [
"static",
"public",
"void",
"free",
"(",
"object",
"object",
")",
"{",
"if",
"(",
"object",
"=",
"=",
"null",
")",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"object",
"cannot",
"be",
"null",
"\"",
")",
";",
"pool",
"pool",
"=",
"type",
"pools",
"get",
"(",
"object",
"get",
"class",
"(",
")",
")",
";",
"if",
"(",
"pool",
"=",
"=",
"null",
")",
"return",
";",
"/",
"/",
"ignore",
"freeing",
"an",
"object",
"that",
"was",
"never",
"retained",
"pool",
"free",
"(",
"object",
")",
";",
"}"
]
|
[
"the",
"raw",
"text",
"of",
"the",
"string",
"<",
"code",
">",
"optional",
"string",
"value",
"=",
"1",
";",
"<",
"code",
">"
]
| [
"public",
"boolean",
"has",
"value",
"(",
")",
"{",
"return",
"instance",
"has",
"value",
"(",
")",
";",
"}"
]
|
[
"report",
"that",
"actions",
"are",
"not",
"getting",
"completed",
"in",
"a",
"timely",
"manner",
"inactivity",
"is",
"typically",
"not",
"reported",
"if",
"tests",
"with",
"streaming",
"output",
"are",
"being",
"run"
]
| [
"void",
"maybe",
"report",
"inactivity",
"(",
")",
";"
]
|
[
"returns",
"the",
"source",
"index",
"name"
]
| [
"public",
"string",
"get",
"source",
"index",
"(",
")",
"{",
"return",
"source",
"index",
";",
"}"
]
|
[
"sets",
"application",
"data"
]
| [
"public",
"void",
"set",
"application",
"data",
"(",
"string",
"application",
"data",
")",
"{",
"this",
"application",
"data",
"=",
"application",
"data",
";",
"}"
]
|
[
"tests",
"cluster",
"storage",
"statistics",
"during",
"decommissioning",
"for",
"federated",
"cluster"
]
| [
"public",
"void",
"test",
"cluster",
"stats",
"federation",
"(",
")",
"throws",
"exception",
"{",
"test",
"cluster",
"stats",
"(",
"3",
")",
";",
"}"
]
|
[
"resolves",
"the",
"specified",
"name",
"into",
"an",
"address"
]
| [
"public",
"final",
"future",
"<",
"inet",
"address",
">",
"resolve",
"(",
"string",
"inet",
"host",
",",
"iterable",
"<",
"dns",
"record",
">",
"additionals",
")",
"{",
"return",
"resolve",
"(",
"inet",
"host",
",",
"additionals",
",",
"executor",
"(",
")",
"<",
"inet",
"address",
">",
"new",
"promise",
"(",
")",
")",
";",
"}"
]
|
[
"returns",
"a",
"description",
"of",
"this",
"source",
"info",
"object"
]
| [
"string",
"get",
"description",
"(",
")",
";"
]
|
[
"set",
"the",
"paths",
"value"
]
| [
"public",
"list",
"result",
"schema",
"with",
"paths",
"(",
"final",
"list",
"<",
"list",
"result",
"entry",
"schema",
">",
"paths",
")",
"{",
"this",
"paths",
"=",
"paths",
";",
"return",
"this",
";",
"}"
]
|
[
"for",
"testing",
"only",
":",
"gets",
"the",
"length",
"of",
"the",
"longest",
"overflow",
"chain",
"this",
"method",
"has",
"linear",
"complexity"
]
| [
"int",
"get",
"longest",
"chain",
"length",
"(",
")",
"{",
"int",
"max",
"len",
"=",
"0",
";",
"for",
"(",
"entry",
"<",
"?",
",",
"?",
">",
"entry",
":",
"table",
")",
"{",
"int",
"this",
"len",
"=",
"0",
";",
"while",
"(",
"entry",
"!",
"=",
"null",
")",
"{",
"this",
"len",
"+",
"+",
";",
"entry",
"=",
"entry",
"next",
";",
"}",
"max",
"len",
"=",
"math",
"max",
"(",
"max",
"len",
",",
"this",
"len",
")",
";",
"}",
"return",
"max",
"len",
";",
"}"
]
|
[
"schedules",
"a",
"set",
"media",
"items",
"action",
"to",
"be",
"executed"
]
| [
"public",
"builder",
"set",
"media",
"sources",
"(",
"int",
"window",
"index",
",",
"long",
"position",
"ms",
",",
"media",
"source",
"sources",
")",
"{",
"return",
"apply",
"(",
"new",
"action",
"set",
"media",
"items",
"(",
"tag",
",",
"window",
"index",
",",
"position",
"ms",
",",
"sources",
")",
")",
";",
"}"
]
|
[
"parses",
"the",
"configuration",
"to",
"get",
"the",
"page",
"size",
"and",
"validates",
"the",
"value"
]
| [
"public",
"static",
"int",
"get",
"page",
"size",
"(",
"configuration",
"configuration",
")",
"{",
"final",
"int",
"page",
"size",
"=",
"checked",
"down",
"cast",
"(",
"configuration",
"get",
"(",
"task",
"manager",
"options",
"memory",
"segment",
"size",
")",
"get",
"bytes",
"(",
")",
")",
";",
"/",
"/",
"check",
"page",
"size",
"of",
"for",
"minimum",
"size",
"check",
"config",
"parameter",
"(",
"page",
"size",
">",
"=",
"memory",
"manager",
"min",
"page",
"size",
",",
"page",
"size",
",",
"task",
"manager",
"options",
"memory",
"segment",
"size",
"key",
"(",
")",
",",
"\"",
"minimum",
"memory",
"segment",
"size",
"is",
"\"",
"+",
"memory",
"manager",
"min",
"page",
"size",
")",
";",
"/",
"/",
"check",
"page",
"size",
"for",
"power",
"of",
"two",
"check",
"config",
"parameter",
"(",
"math",
"utils",
"is",
"power",
"of",
"2",
"(",
"page",
"size",
")",
",",
"page",
"size",
",",
"task",
"manager",
"options",
"memory",
"segment",
"size",
"key",
"(",
")",
",",
"\"",
"memory",
"segment",
"size",
"must",
"be",
"a",
"power",
"of",
"2",
"\"",
")",
";",
"return",
"page",
"size",
";",
"}"
]
|
[
"promotes",
"the",
"entry",
"to",
"the",
"protected",
"region",
"'",
"s",
"mru",
"position",
",",
"demoting",
"an",
"entry",
"if",
"necessary"
]
| [
"private",
"void",
"on",
"probation",
"hit",
"(",
"node",
"node",
")",
"{",
"node",
"remove",
"(",
")",
";",
"node",
"queue",
"=",
"protected",
";",
"node",
"append",
"to",
"tail",
"(",
"head",
"protected",
")",
";",
"protected",
"size",
"+",
"+",
";",
"demote",
"protected",
"(",
")",
";",
"}"
]
|
[
"the",
"last",
"character",
"position",
"this",
"span",
"applies",
"to",
",",
"in",
"utf",
"-",
"16",
"offset",
"<",
"code",
">",
"optional",
"uint",
"3",
"2",
"last",
"char",
"=",
"3",
";",
"<",
"code",
">"
]
| [
"int",
"get",
"last",
"char",
"(",
")",
";"
]
|
[
"indicates",
"whether",
"the",
"given",
"character",
"is",
"in",
"the",
"{",
"@",
"code",
"reserved",
"}",
"set"
]
| [
"protected",
"boolean",
"is",
"reserved",
"(",
"int",
"c",
")",
"{",
"return",
"(",
"is",
"generic",
"delimiter",
"(",
"c",
")",
"|",
"|",
"is",
"sub",
"delimiter",
"(",
"c",
")",
")",
";",
"}"
]
|
[
"creates",
"a",
"map",
"of",
"rule",
"names",
"(",
"keys",
")",
"to",
"rule",
"documentation",
"(",
"values",
")",
"this",
"method",
"crawls",
"the",
"specified",
"input",
"directories",
"for",
"rule",
"class",
"definitions",
"(",
"as",
"java",
"source",
"files",
")",
"which",
"contain",
"the",
"rules",
"'",
"and",
"attributes",
"'",
"definitions",
"as",
"comments",
"in",
"a",
"specific",
"format",
"the",
"keys",
"in",
"the",
"returned",
"map",
"correspond",
"to",
"these",
"rule",
"classes",
"in",
"the",
"map",
"'",
"s",
"values",
",",
"all",
"references",
"pointing",
"to",
"other",
"rules",
",",
"rule",
"attributes",
",",
"and",
"general",
"documentation",
"(",
"e",
"g",
"common",
"definitions",
",",
"make",
"variables",
",",
"etc",
")",
"are",
"expanded",
"into",
"hyperlinks",
"the",
"links",
"generated",
"follow",
"the",
"multi",
"-",
"page",
"build",
"encyclopedia",
"model",
"(",
"one",
"page",
"per",
"rule",
"class",
")"
]
| [
"public",
"map",
"<",
"string",
",",
"rule",
"documentation",
">",
"collect",
"(",
"list",
"<",
"string",
">",
"input",
"dirs",
",",
"string",
"deny",
"list",
")",
"throws",
"build",
"encyclopedia",
"doc",
"exception",
",",
"i",
"o",
"exception",
"{",
"rule",
"link",
"expander",
"expander",
"=",
"new",
"rule",
"link",
"expander",
"(",
"product",
"name",
",",
"/",
"*",
"single",
"page",
"*",
"/",
"false",
")",
";",
"return",
"collect",
"(",
"input",
"dirs",
",",
"deny",
"list",
",",
"expander",
")",
";",
"}"
]
|
[
"customize",
"the",
"client",
"builder",
"this",
"method",
"can",
"be",
"overriden",
"to",
"customize",
"the",
"api",
"client",
"for",
"example",
",",
"this",
"can",
"be",
"used",
"to",
":",
"1",
"set",
"the",
"hostname",
"verifier",
"to",
"be",
"used",
"by",
"the",
"client",
"to",
"verify",
"the",
"endpoint",
"'",
"s",
"hostname",
"against",
"its",
"identification",
"information",
"2",
"set",
"the",
"client",
"-",
"side",
"key",
"store",
"3",
"set",
"the",
"ssl",
"context",
"that",
"will",
"be",
"used",
"when",
"creating",
"secured",
"transport",
"connections",
"to",
"server",
"endpoints",
"from",
"web",
"targets",
"created",
"by",
"the",
"client",
"instance",
"that",
"is",
"using",
"this",
"ssl",
"context",
"4",
"set",
"the",
"client",
"-",
"side",
"trust",
"store",
"to",
"completely",
"disable",
"certificate",
"validation",
"(",
"at",
"your",
"own",
"risk",
")",
",",
"you",
"can",
"override",
"this",
"method",
"and",
"invoke",
"disable",
"certificate",
"validation",
"(",
"client",
"builder",
")"
]
| [
"protected",
"void",
"customize",
"client",
"builder",
"(",
"client",
"builder",
"client",
"builder",
")",
"{",
"/",
"/",
"no",
"-",
"op",
"extension",
"point",
"}"
]
|
[
"returns",
"true",
"if",
"this",
"is",
"a",
"request",
"for",
"the",
"special",
"build",
"prelude",
"file"
]
| [
"boolean",
"is",
"build",
"prelude",
"(",
")",
"{",
"return",
"false",
";",
"}"
]
|
[
"sets",
"the",
"function",
"return",
"type"
]
| [
"public",
"void",
"set",
"return",
"type",
"(",
"demangled",
"data",
"type",
"return",
"type",
")",
"{",
"this",
"return",
"type",
"=",
"return",
"type",
";",
"}"
]
|
[
"unprotected",
"truncate",
"implementation",
"unlike",
"{",
"@",
"link",
"f",
"s",
"dir",
"truncate",
"op",
"#",
"truncate",
"}",
",",
"this",
"will",
"not",
"schedule",
"block",
"recovery"
]
| [
"static",
"void",
"unprotected",
"truncate",
"(",
"final",
"f",
"s",
"namesystem",
"fsn",
",",
"final",
"i",
"nodes",
"in",
"path",
"iip",
",",
"final",
"string",
"client",
"name",
",",
"final",
"string",
"client",
"machine",
",",
"final",
"long",
"new",
"length",
",",
"final",
"long",
"mtime",
",",
"final",
"block",
"truncate",
"block",
")",
"throws",
"unresolved",
"link",
"exception",
",",
"quota",
"exceeded",
"exception",
",",
"snapshot",
"access",
"control",
"exception",
",",
"i",
"o",
"exception",
"{",
"assert",
"fsn",
"has",
"write",
"lock",
"(",
")",
";",
"f",
"s",
"directory",
"fsd",
"=",
"fsn",
"get",
"f",
"s",
"directory",
"(",
")",
";",
"i",
"node",
"file",
"file",
"=",
"iip",
"get",
"last",
"i",
"node",
"(",
")",
"as",
"file",
"(",
")",
";",
"blocks",
"map",
"update",
"info",
"collected",
"blocks",
"=",
"new",
"blocks",
"map",
"update",
"info",
"(",
")",
";",
"boolean",
"on",
"block",
"boundary",
"=",
"unprotected",
"truncate",
"(",
"fsn",
",",
"iip",
",",
"new",
"length",
",",
"collected",
"blocks",
",",
"mtime",
",",
"null",
")",
";",
"if",
"(",
"!",
"on",
"block",
"boundary",
")",
"{",
"block",
"info",
"old",
"block",
"=",
"file",
"get",
"last",
"block",
"(",
")",
";",
"block",
"t",
"blk",
"=",
"prepare",
"file",
"for",
"truncate",
"(",
"fsn",
",",
"iip",
",",
"client",
"name",
",",
"client",
"machine",
",",
"file",
"compute",
"file",
"size",
"(",
")",
"-",
"new",
"length",
",",
"truncate",
"block",
")",
";",
"assert",
"block",
"matching",
"id",
"and",
"gen",
"stamp",
"(",
"t",
"blk",
",",
"truncate",
"block",
")",
"&",
"&",
"t",
"blk",
"get",
"num",
"bytes",
"(",
")",
"=",
"=",
"truncate",
"block",
"get",
"num",
"bytes",
"(",
")",
":",
"\"",
"should",
"be",
"the",
"same",
"block",
"\"",
";",
"if",
"(",
"old",
"block",
"get",
"block",
"id",
"(",
")",
"!",
"=",
"t",
"blk",
"get",
"block",
"id",
"(",
")",
"&",
"&",
"!",
"file",
"is",
"block",
"in",
"latest",
"snapshot",
"(",
"old",
"block",
")",
")",
"{",
"old",
"block",
"delete",
"(",
")",
";",
"fsd",
"get",
"block",
"manager",
"(",
")",
"remove",
"block",
"from",
"map",
"(",
"old",
"block",
")",
";",
"}",
"}",
"assert",
"on",
"block",
"boundary",
"=",
"=",
"(",
"truncate",
"block",
"=",
"=",
"null",
")",
":",
"\"",
"truncate",
"block",
"is",
"null",
"iff",
"on",
"block",
"boundary",
":",
"\"",
"+",
"truncate",
"block",
";",
"fsn",
"get",
"block",
"manager",
"(",
")",
"remove",
"blocks",
"and",
"update",
"safemode",
"total",
"(",
"collected",
"blocks",
")",
";",
"}"
]
|
[
"get",
"the",
"reader",
"(",
"andor",
"reader",
"group",
")",
"list",
"string"
]
| [
"public",
"string",
"get",
"readers",
"(",
")",
"{",
"return",
"readers",
";",
"}"
]
|
[
"returns",
"prefix",
"string",
"that",
"should",
"be",
"instrumented",
"for",
"a",
"given",
"package",
"input",
"string",
"should",
"be",
"formatted",
"like",
"the",
"output",
"of",
"label",
"get",
"package",
"name",
"(",
")",
"generally",
",",
"package",
"name",
"will",
"be",
"used",
"as",
"such",
"string",
"with",
"two",
"modifications",
"-",
"\"",
"javatests",
"directories",
"will",
"be",
"substituted",
"with",
"\"",
"java",
"\"",
",",
"since",
"we",
"do",
"not",
"want",
"to",
"instrument",
"java",
"test",
"code",
"\"",
"java",
"\"",
"directories",
"in",
"\"",
"test",
"\"",
"will",
"be",
"replaced",
"by",
"the",
"same",
"in",
"\"",
"main",
"\"",
"-",
"\"",
"internal",
"\"",
",",
"\"",
"public",
"\"",
",",
"and",
"\"",
"tests",
"\"",
"package",
"suffix",
"will",
"be",
"dropped",
",",
"since",
"usually",
"we",
"would",
"want",
"to",
"instrument",
"code",
"in",
"the",
"parent",
"package",
"as",
"well"
]
| [
"public",
"static",
"string",
"get",
"instrumented",
"prefix",
"(",
"string",
"package",
"name",
")",
"{",
"if",
"(",
"package",
"name",
"ends",
"with",
"(",
"\"",
"/",
"internal",
"\"",
")",
")",
"{",
"package",
"name",
"=",
"package",
"name",
"substring",
"(",
"0",
",",
"package",
"name",
"length",
"(",
")",
"-",
"\"",
"/",
"internal",
"\"",
"length",
"(",
")",
")",
";",
"}",
"else",
"if",
"(",
"package",
"name",
"ends",
"with",
"(",
"\"",
"/",
"public",
"\"",
")",
")",
"{",
"package",
"name",
"=",
"package",
"name",
"substring",
"(",
"0",
",",
"package",
"name",
"length",
"(",
")",
"-",
"\"",
"/",
"public",
"\"",
"length",
"(",
")",
")",
";",
"}",
"else",
"if",
"(",
"package",
"name",
"ends",
"with",
"(",
"\"",
"/",
"tests",
"\"",
")",
")",
"{",
"package",
"name",
"=",
"package",
"name",
"substring",
"(",
"0",
",",
"package",
"name",
"length",
"(",
")",
"-",
"\"",
"/",
"tests",
"\"",
"length",
"(",
")",
")",
";",
"}",
"return",
"package",
"name",
"replace",
"first",
"(",
"\"",
"(",
"?",
"<",
"=",
"^",
"|",
"/",
")",
"javatests",
"/",
"\"",
",",
"\"",
"java",
"/",
"\"",
")",
"replace",
"first",
"(",
"\"",
"(",
"?",
"<",
"=",
"^",
"|",
"/",
")",
"test",
"/",
"java",
"/",
"\"",
",",
"\"",
"main",
"/",
"java",
"/",
"\"",
")",
";",
"}"
]
|
[
"returns",
"the",
"commands",
"of",
"this",
"instance",
"arguments",
"with",
"spaces",
"in",
"are",
"presented",
"with",
"quotes",
"round",
";",
"other",
"arguments",
"are",
"presented",
"raw"
]
| [
"public",
"string",
"to",
"string",
"(",
")",
"{",
"string",
"builder",
"builder",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"string",
"[",
"]",
"args",
"=",
"exec",
"string",
"(",
")",
";",
"for",
"(",
"string",
"s",
":",
"args",
")",
"{",
"if",
"(",
"s",
"index",
"of",
"(",
"'",
"'",
")",
">",
"=",
"0",
")",
"{",
"builder",
"append",
"(",
"'",
"\"",
"'",
")",
"append",
"(",
"s",
")",
"append",
"(",
"'",
"\"",
"'",
")",
";",
"}",
"else",
"{",
"builder",
"append",
"(",
"s",
")",
";",
"}",
"builder",
"append",
"(",
"'",
"'",
")",
";",
"}",
"return",
"builder",
"to",
"string",
"(",
")",
";",
"}"
]
|
[
"called",
"iff",
"the",
"directory",
"contains",
"a",
"build",
"file",
"but",
"not",
"a",
"package",
",",
"which",
"can",
"happen",
"under",
"the",
"following",
"circumstances",
":",
"the",
"build",
"file",
"contains",
"a",
"starlark",
"load",
"statement",
"that",
"is",
"in",
"error",
"todo",
"(",
"mschaller",
")",
",",
"not",
"yet",
"implemented",
":",
"the",
"build",
"file",
"is",
"a",
"symlink",
"that",
"points",
"into",
"a",
"cycle"
]
| [
"void",
"note",
"package",
"error",
"(",
"string",
"no",
"such",
"package",
"exception",
"error",
"message",
")",
";"
]
|
[
"split",
"a",
"command",
"string",
"into",
"individual",
"arguments"
]
| [
"private",
"static",
"string",
"[",
"]",
"split",
"command",
"(",
"string",
"cmd",
")",
"{",
"array",
"list",
"<",
"string",
">",
"arg",
"list",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"int",
"start",
"ix",
"=",
"0",
";",
"int",
"end",
"ix",
"=",
"0",
";",
"int",
"len",
"=",
"cmd",
"length",
"(",
")",
";",
"boolean",
"inside",
"quote",
"=",
"false",
";",
"while",
"(",
"end",
"ix",
"<",
"len",
")",
"{",
"char",
"c",
"=",
"cmd",
"char",
"at",
"(",
"end",
"ix",
")",
";",
"if",
"(",
"!",
"inside",
"quote",
"&",
"&",
"start",
"ix",
"=",
"=",
"end",
"ix",
")",
"{",
"if",
"(",
"c",
"=",
"=",
"'",
"'",
"|",
"|",
"c",
"=",
"=",
"'",
"\\",
"\"",
"'",
")",
"{",
"inside",
"quote",
"=",
"(",
"c",
"=",
"=",
"'",
"\\",
"\"",
"'",
")",
";",
"start",
"ix",
"=",
"+",
"+",
"end",
"ix",
";",
"continue",
";",
"}",
"}",
"if",
"(",
"c",
"=",
"=",
"(",
"inside",
"quote",
"?",
"'",
"\\",
"\"",
"'",
":",
"'",
"'",
")",
")",
"{",
"arg",
"list",
"add",
"(",
"cmd",
"substring",
"(",
"start",
"ix",
",",
"end",
"ix",
")",
")",
";",
"start",
"ix",
"=",
"+",
"+",
"end",
"ix",
";",
"inside",
"quote",
"=",
"false",
";",
"}",
"else",
"{",
"+",
"+",
"end",
"ix",
";",
"}",
"}",
"if",
"(",
"start",
"ix",
"!",
"=",
"end",
"ix",
")",
"{",
"arg",
"list",
"add",
"(",
"cmd",
"substring",
"(",
"start",
"ix",
",",
"end",
"ix",
")",
")",
";",
"}",
"string",
"[",
"]",
"args",
"=",
"new",
"string",
"[",
"arg",
"list",
"size",
"(",
")",
"]",
";",
"arg",
"list",
"to",
"array",
"(",
"args",
")",
";",
"return",
"args",
";",
"}"
]
|
[
"copies",
"the",
"given",
"instruction",
"into",
"this",
"instruction"
]
| [
"public",
"look",
"up",
"switch",
"instruction",
"copy",
"(",
"look",
"up",
"switch",
"instruction",
"look",
"up",
"switch",
"instruction",
")",
"{",
"this",
"opcode",
"=",
"look",
"up",
"switch",
"instruction",
"opcode",
";",
"this",
"default",
"offset",
"=",
"look",
"up",
"switch",
"instruction",
"default",
"offset",
";",
"this",
"cases",
"=",
"look",
"up",
"switch",
"instruction",
"cases",
";",
"this",
"jump",
"offsets",
"=",
"look",
"up",
"switch",
"instruction",
"jump",
"offsets",
";",
"return",
"this",
";",
"}"
]
|
[
"is",
"this",
"committer",
"using",
"unique",
"filenames",
"?"
]
| [
"public",
"boolean",
"use",
"unique",
"filenames",
"(",
")",
"{",
"return",
"unique",
"filenames",
";",
"}"
]
|
[
"checks",
"whether",
"or",
"not",
"the",
"given",
"tool",
"is",
"currently",
"executing",
"a",
"background",
"task"
]
| [
"boolean",
"is",
"tool",
"executing",
"command",
"(",
"plugin",
"tool",
"tool",
")",
"{",
"return",
"tool",
"!",
"=",
"null",
"&",
"&",
"tool",
"is",
"executing",
"command",
"(",
")",
";",
"}"
]
|
[
"{",
"@",
"inherit",
"doc",
"}"
]
| [
"public",
"void",
"update",
"n",
"clob",
"(",
"string",
"column",
"label",
",",
"reader",
"reader",
")",
"throws",
"s",
"q",
"l",
"exception",
"{",
"}"
]
|
[
"test",
"the",
"property",
"'",
"array",
"item",
"'"
]
| [
"public",
"void",
"array",
"item",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"array",
"item",
"}"
]
|
[
"required",
"the",
"ports",
"associated",
"with",
"the",
"external",
"service",
"if",
"the",
"endpoints",
"are",
"unix",
"domain",
"socket",
"addresses",
",",
"there",
"must",
"be",
"exactly",
"one",
"port",
"<",
"code",
">",
"repeated",
"istio",
"networking",
"v",
"1alpha",
"3",
"port",
"ports",
"=",
"3",
";",
"<",
"code",
">"
]
| [
"public",
"com",
"alibaba",
"nacos",
"istio",
"model",
"port",
"builder",
"add",
"ports",
"builder",
"(",
")",
"{",
"return",
"get",
"ports",
"field",
"builder",
"(",
")",
"add",
"builder",
"(",
"com",
"alibaba",
"nacos",
"istio",
"model",
"port",
"get",
"default",
"instance",
"(",
")",
")",
";",
"}"
]
|
[
"get",
"the",
"current",
"working",
"directory",
"for",
"the",
"default",
"file",
"system"
]
| [
"public",
"path",
"get",
"working",
"directory",
"(",
")",
"{",
"string",
"name",
"=",
"get",
"(",
"job",
"context",
"working",
"dir",
")",
";",
"if",
"(",
"name",
"!",
"=",
"null",
")",
"{",
"return",
"new",
"path",
"(",
"name",
")",
";",
"}",
"else",
"{",
"try",
"{",
"path",
"dir",
"=",
"file",
"system",
"get",
"(",
"this",
")",
"get",
"working",
"directory",
"(",
")",
";",
"set",
"(",
"job",
"context",
"working",
"dir",
",",
"dir",
"to",
"string",
"(",
")",
")",
";",
"return",
"dir",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"e",
")",
";",
"}",
"}",
"}"
]
|
[
"get",
"number",
"minimum",
":",
"32",
"1",
"maximum",
":",
"543",
"2"
]
| [
"public",
"big",
"decimal",
"get",
"number",
"(",
")",
"{",
"return",
"number",
";",
"}"
]
|
[
"verify",
"a",
"dn",
"remains",
"in",
"decommission",
"inprogress",
"state",
"if",
"it",
"is",
"marked",
"as",
"dead",
"before",
"decommission",
"has",
"completed",
"that",
"will",
"allow",
"dn",
"to",
"resume",
"the",
"replication",
"process",
"after",
"it",
"rejoins",
"the",
"cluster"
]
| [
"public",
"void",
"test",
"decommission",
"status",
"after",
"d",
"n",
"restart",
"(",
")",
"throws",
"exception",
"{",
"distributed",
"file",
"system",
"file",
"sys",
"=",
"(",
"distributed",
"file",
"system",
")",
"cluster",
"get",
"file",
"system",
"(",
")",
";",
"/",
"/",
"create",
"a",
"file",
"with",
"one",
"block",
"that",
"block",
"has",
"one",
"replica",
"path",
"f",
"=",
"new",
"path",
"(",
"\"",
"decommission",
"dat",
"\"",
")",
";",
"d",
"f",
"s",
"test",
"util",
"create",
"file",
"(",
"file",
"sys",
",",
"f",
",",
"file",
"size",
",",
"file",
"size",
",",
"file",
"size",
",",
"(",
"short",
")",
"1",
",",
"seed",
")",
";",
"/",
"/",
"find",
"the",
"dn",
"that",
"owns",
"the",
"only",
"replica",
"remote",
"iterator",
"<",
"located",
"file",
"status",
">",
"file",
"list",
"=",
"file",
"sys",
"list",
"located",
"status",
"(",
"f",
")",
";",
"block",
"location",
"[",
"]",
"block",
"locations",
"=",
"file",
"list",
"next",
"(",
")",
"get",
"block",
"locations",
"(",
")",
";",
"string",
"dn",
"name",
"=",
"block",
"locations",
"[",
"0",
"]",
"get",
"names",
"(",
")",
"[",
"0",
"]",
";",
"/",
"/",
"decommission",
"the",
"dn",
"f",
"s",
"namesystem",
"fsn",
"=",
"cluster",
"get",
"namesystem",
"(",
")",
";",
"final",
"datanode",
"manager",
"dm",
"=",
"fsn",
"get",
"block",
"manager",
"(",
")",
"get",
"datanode",
"manager",
"(",
")",
";",
"decommission",
"node",
"(",
"dn",
"name",
")",
";",
"dm",
"refresh",
"nodes",
"(",
"conf",
")",
";",
"/",
"/",
"stop",
"the",
"dn",
"when",
"decommission",
"is",
"in",
"progress",
"/",
"/",
"given",
"dfs",
"datanode",
"balance",
"bandwidthpersec",
"key",
"is",
"to",
"1",
"and",
"the",
"size",
"of",
"/",
"/",
"the",
"block",
",",
"it",
"will",
"take",
"much",
"longer",
"time",
"that",
"test",
"timeout",
"value",
"for",
"/",
"/",
"the",
"decommission",
"to",
"complete",
"so",
"when",
"stop",
"data",
"node",
"is",
"called",
",",
"/",
"/",
"decommission",
"should",
"be",
"in",
"progress",
"data",
"node",
"properties",
"data",
"node",
"properties",
"=",
"cluster",
"stop",
"data",
"node",
"(",
"dn",
"name",
")",
";",
"final",
"list",
"<",
"datanode",
"descriptor",
">",
"dead",
"=",
"new",
"array",
"list",
"<",
"datanode",
"descriptor",
">",
"(",
")",
";",
"while",
"(",
"true",
")",
"{",
"dm",
"fetch",
"datanodes",
"(",
"null",
",",
"dead",
",",
"false",
")",
";",
"if",
"(",
"dead",
"size",
"(",
")",
"=",
"=",
"1",
")",
"{",
"break",
";",
"}",
"thread",
"sleep",
"(",
"1000",
")",
";",
"}",
"/",
"/",
"force",
"removal",
"of",
"the",
"dead",
"node",
"'",
"s",
"blocks",
"block",
"manager",
"test",
"util",
"check",
"heartbeat",
"(",
"fsn",
"get",
"block",
"manager",
"(",
")",
")",
";",
"/",
"/",
"force",
"datanode",
"manager",
"to",
"check",
"decommission",
"state",
"block",
"manager",
"test",
"util",
"recheck",
"decommission",
"state",
"(",
"dm",
")",
";",
"/",
"/",
"block",
"until",
"the",
"admin",
"'",
"s",
"monitor",
"updates",
"the",
"number",
"of",
"tracked",
"nodes",
"wait",
"for",
"decommissioned",
"nodes",
"(",
"dm",
"get",
"datanode",
"admin",
"manager",
"(",
")",
",",
"1",
")",
";",
"/",
"/",
"verify",
"that",
"the",
"dn",
"remains",
"in",
"decommission",
"inprogress",
"state",
"assert",
"true",
"(",
"\"",
"the",
"node",
"should",
"be",
"decommission",
"in",
"progresss",
"\"",
",",
"dead",
"get",
"(",
"0",
")",
"is",
"decommission",
"in",
"progress",
"(",
")",
")",
";",
"/",
"/",
"check",
"datanode",
"manager",
"#",
"get",
"decommission",
"nodes",
",",
"make",
"sure",
"it",
"returns",
"/",
"/",
"the",
"node",
"as",
"decommissioning",
",",
"even",
"if",
"it",
"'",
"s",
"dead",
"list",
"<",
"datanode",
"descriptor",
">",
"decomlist",
"=",
"dm",
"get",
"decommissioning",
"nodes",
"(",
")",
";",
"assert",
"true",
"(",
"\"",
"the",
"node",
"should",
"be",
"be",
"decommissioning",
"\"",
",",
"decomlist",
"size",
"(",
")",
"=",
"=",
"1",
")",
";",
"/",
"/",
"delete",
"the",
"under",
"-",
"replicated",
"file",
",",
"which",
"should",
"let",
"the",
"/",
"/",
"decommission",
"in",
"progress",
"node",
"become",
"decommissioned",
"admin",
"states",
"base",
"test",
"cleanup",
"file",
"(",
"file",
"sys",
",",
"f",
")",
";",
"block",
"manager",
"test",
"util",
"recheck",
"decommission",
"state",
"(",
"dm",
")",
";",
"/",
"/",
"block",
"until",
"the",
"admin",
"'",
"s",
"monitor",
"updates",
"the",
"number",
"of",
"tracked",
"nodes",
"wait",
"for",
"decommissioned",
"nodes",
"(",
"dm",
"get",
"datanode",
"admin",
"manager",
"(",
")",
",",
"0",
")",
";",
"assert",
"true",
"(",
"\"",
"the",
"node",
"should",
"be",
"decommissioned",
"\"",
",",
"dead",
"get",
"(",
"0",
")",
"is",
"decommissioned",
"(",
")",
")",
";",
"/",
"/",
"add",
"the",
"node",
"back",
"cluster",
"restart",
"data",
"node",
"(",
"data",
"node",
"properties",
",",
"true",
")",
";",
"cluster",
"wait",
"active",
"(",
")",
";",
"/",
"/",
"call",
"refresh",
"nodes",
"on",
"f",
"s",
"namesystem",
"with",
"empty",
"exclude",
"file",
"/",
"/",
"this",
"will",
"remove",
"the",
"datanodes",
"from",
"decommissioning",
"list",
"and",
"/",
"/",
"make",
"them",
"available",
"again",
"hosts",
"file",
"writer",
"init",
"exclude",
"host",
"(",
"\"",
"\"",
")",
";",
"dm",
"refresh",
"nodes",
"(",
"conf",
")",
";",
"}"
]
|
[
"assert",
"the",
"name",
"of",
"the",
"controller",
"method",
"used",
"to",
"process",
"the",
"request",
"using",
"the",
"given",
"hamcrest",
"{",
"@",
"link",
"matcher",
"}"
]
| [
"public",
"result",
"matcher",
"method",
"name",
"(",
"matcher",
"<",
"?",
"super",
"string",
">",
"matcher",
")",
"{",
"return",
"result",
"-",
">",
"{",
"handler",
"method",
"handler",
"method",
"=",
"get",
"handler",
"method",
"(",
"result",
")",
";",
"assert",
"that",
"(",
"\"",
"handler",
"method",
"\"",
",",
"handler",
"method",
"get",
"method",
"(",
")",
"get",
"name",
"(",
")",
",",
"matcher",
")",
";",
"}",
";",
"}"
]
|
[
"move",
"the",
"captured",
"settling",
"view",
"by",
"the",
"appropriate",
"amount",
"for",
"the",
"current",
"time",
"if",
"<",
"code",
">",
"continue",
"settling",
"<",
"code",
">",
"returns",
"true",
",",
"the",
"caller",
"should",
"call",
"it",
"again",
"on",
"the",
"next",
"frame",
"to",
"continue"
]
| [
"public",
"boolean",
"continue",
"settling",
"(",
"boolean",
"defer",
"callbacks",
")",
"{",
"/",
"/",
"make",
"sure",
",",
"there",
"is",
"a",
"captured",
"view",
"if",
"(",
"m",
"captured",
"view",
"=",
"=",
"null",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"m",
"drag",
"state",
"=",
"=",
"state",
"settling",
")",
"{",
"boolean",
"keep",
"going",
"=",
"m",
"scroller",
"compute",
"scroll",
"offset",
"(",
")",
";",
"final",
"int",
"x",
"=",
"m",
"scroller",
"get",
"curr",
"x",
"(",
")",
";",
"final",
"int",
"y",
"=",
"m",
"scroller",
"get",
"curr",
"y",
"(",
")",
";",
"final",
"int",
"dx",
"=",
"x",
"-",
"m",
"captured",
"view",
"get",
"left",
"(",
")",
";",
"final",
"int",
"dy",
"=",
"y",
"-",
"m",
"captured",
"view",
"get",
"top",
"(",
")",
";",
"if",
"(",
"!",
"keep",
"going",
"&",
"&",
"dy",
"!",
"=",
"0",
")",
"{",
"/",
"/",
"fix",
"#",
"525",
"/",
"/",
"invalid",
"drag",
"state",
"m",
"captured",
"view",
"set",
"top",
"(",
"0",
")",
";",
"return",
"true",
";",
"}",
"if",
"(",
"dx",
"!",
"=",
"0",
")",
"{",
"m",
"captured",
"view",
"offset",
"left",
"and",
"right",
"(",
"dx",
")",
";",
"}",
"if",
"(",
"dy",
"!",
"=",
"0",
")",
"{",
"m",
"captured",
"view",
"offset",
"top",
"and",
"bottom",
"(",
"dy",
")",
";",
"}",
"if",
"(",
"dx",
"!",
"=",
"0",
"|",
"|",
"dy",
"!",
"=",
"0",
")",
"{",
"m",
"callback",
"on",
"view",
"position",
"changed",
"(",
"m",
"captured",
"view",
",",
"x",
",",
"y",
",",
"dx",
",",
"dy",
")",
";",
"}",
"if",
"(",
"keep",
"going",
"&",
"&",
"x",
"=",
"=",
"m",
"scroller",
"get",
"final",
"x",
"(",
")",
"&",
"&",
"y",
"=",
"=",
"m",
"scroller",
"get",
"final",
"y",
"(",
")",
")",
"{",
"/",
"/",
"close",
"enough",
"the",
"interpolator",
"/",
"scroller",
"might",
"think",
"we",
"'",
"re",
"still",
"moving",
"/",
"/",
"but",
"the",
"user",
"sure",
"doesn",
"'",
"t",
"m",
"scroller",
"abort",
"animation",
"(",
")",
";",
"keep",
"going",
"=",
"m",
"scroller",
"is",
"finished",
"(",
")",
";",
"}",
"if",
"(",
"!",
"keep",
"going",
")",
"{",
"if",
"(",
"defer",
"callbacks",
")",
"{",
"m",
"parent",
"view",
"post",
"(",
"m",
"set",
"idle",
"runnable",
")",
";",
"}",
"else",
"{",
"set",
"drag",
"state",
"(",
"state",
"idle",
")",
";",
"}",
"}",
"}",
"return",
"m",
"drag",
"state",
"=",
"=",
"state",
"settling",
";",
"}"
]
|
[
"returns",
"an",
"integer",
"value",
"with",
"value",
"-",
"1",
",",
"0",
",",
"or",
"1",
",",
"if",
"this",
"double",
"value",
"is",
"less",
"than",
",",
"equal",
"to",
",",
"or",
"greater",
"than",
"the",
"given",
"particular",
"double",
"value",
",",
"respectively"
]
| [
"public",
"integer",
"value",
"compare",
"(",
"particular",
"double",
"value",
"other",
")",
"{",
"return",
"compare",
"(",
"(",
"specific",
"double",
"value",
")",
"other",
")",
";",
"}"
]
|
[
"find",
"an",
"{",
"@",
"code",
"@",
"message",
"exception",
"handler",
"}",
"method",
"for",
"the",
"given",
"exception",
"the",
"default",
"implementation",
"searches",
"methods",
"in",
"the",
"class",
"hierarchy",
"of",
"the",
"handler",
"method",
"first",
"and",
"if",
"not",
"found",
",",
"it",
"continues",
"searching",
"for",
"additional",
"{",
"@",
"code",
"@",
"message",
"exception",
"handler",
"}",
"methods",
"among",
"the",
"configured",
"{",
"@",
"linkplain",
"org",
"springframework",
"messaging",
"handler",
"messaging",
"advice",
"bean",
"messaging",
"advice",
"bean",
"}",
",",
"if",
"any"
]
| [
"protected",
"invocable",
"handler",
"method",
"get",
"exception",
"handler",
"method",
"(",
"handler",
"method",
"handler",
"method",
",",
"exception",
"exception",
")",
"{",
"if",
"(",
"logger",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"logger",
"debug",
"(",
"\"",
"searching",
"methods",
"to",
"handle",
"\"",
"+",
"exception",
"get",
"class",
"(",
")",
"get",
"simple",
"name",
"(",
")",
")",
";",
"}",
"class",
"<",
"?",
">",
"bean",
"type",
"=",
"handler",
"method",
"get",
"bean",
"type",
"(",
")",
";",
"abstract",
"exception",
"handler",
"method",
"resolver",
"resolver",
"=",
"this",
"exception",
"handler",
"cache",
"get",
"(",
"bean",
"type",
")",
";",
"if",
"(",
"resolver",
"=",
"=",
"null",
")",
"{",
"resolver",
"=",
"create",
"exception",
"handler",
"method",
"resolver",
"for",
"(",
"bean",
"type",
")",
";",
"this",
"exception",
"handler",
"cache",
"put",
"(",
"bean",
"type",
",",
"resolver",
")",
";",
"}",
"method",
"method",
"=",
"resolver",
"resolve",
"method",
"(",
"exception",
")",
";",
"if",
"(",
"method",
"!",
"=",
"null",
")",
"{",
"return",
"new",
"invocable",
"handler",
"method",
"(",
"handler",
"method",
"get",
"bean",
"(",
")",
",",
"method",
")",
";",
"}",
"for",
"(",
"map",
"entry",
"<",
"messaging",
"advice",
"bean",
",",
"abstract",
"exception",
"handler",
"method",
"resolver",
">",
"entry",
":",
"this",
"exception",
"handler",
"advice",
"cache",
"entry",
"set",
"(",
")",
")",
"{",
"messaging",
"advice",
"bean",
"advice",
"=",
"entry",
"get",
"key",
"(",
")",
";",
"if",
"(",
"advice",
"is",
"applicable",
"to",
"bean",
"type",
"(",
"bean",
"type",
")",
")",
"{",
"resolver",
"=",
"entry",
"get",
"value",
"(",
")",
";",
"method",
"=",
"resolver",
"resolve",
"method",
"(",
"exception",
")",
";",
"if",
"(",
"method",
"!",
"=",
"null",
")",
"{",
"return",
"new",
"invocable",
"handler",
"method",
"(",
"advice",
"resolve",
"bean",
"(",
")",
",",
"method",
")",
";",
"}",
"}",
"}",
"return",
"null",
";",
"}"
]
|
[
"model",
"tests",
"for",
"file",
"schema",
"test",
"class"
]
| [
"public",
"void",
"test",
"file",
"schema",
"test",
"class",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"file",
"schema",
"test",
"class",
"}"
]
|
[
"add",
"initialized",
"memory",
"\"",
"section",
"\"",
"based",
"upon",
"a",
"specified",
"data",
"source",
"file",
"offset",
"the",
"last",
"\"",
"section",
"\"",
"defined",
"will",
"take",
"precedence",
"when",
"resolving",
"conflicts",
"sections",
"identified",
"as",
"loaded",
"will",
"take",
"precedence",
"over",
"those",
"that",
"are",
"non",
"-",
"loaded",
"placed",
"into",
"memory"
]
| [
"public",
"void",
"add",
"initialized",
"memory",
"section",
"(",
"memory",
"loadable",
"key",
",",
"long",
"file",
"offset",
",",
"long",
"number",
"of",
"bytes",
",",
"address",
"start",
"address",
",",
"string",
"section",
"name",
",",
"boolean",
"is",
"readable",
",",
"boolean",
"is",
"writable",
",",
"boolean",
"is",
"executable",
",",
"string",
"comment",
",",
"boolean",
"is",
"fragmentation",
"o",
"k",
",",
"boolean",
"is",
"loaded",
"section",
")",
"throws",
"address",
"overflow",
"exception",
"{",
"if",
"(",
"section",
"memory",
"map",
"!",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"already",
"resolved",
"\"",
")",
";",
"}",
"section",
"name",
"=",
"get",
"unique",
"section",
"name",
"(",
"section",
"name",
")",
";",
"memory",
"section",
"memory",
"section",
"=",
"new",
"memory",
"section",
"(",
"key",
",",
"true",
",",
"file",
"offset",
",",
"number",
"of",
"bytes",
",",
"make",
"range",
"(",
"start",
"address",
",",
"number",
"of",
"bytes",
")",
",",
"section",
"name",
",",
"is",
"readable",
",",
"is",
"writable",
",",
"is",
"executable",
",",
"comment",
",",
"is",
"fragmentation",
"o",
"k",
")",
";",
"if",
"(",
"is",
"loaded",
"section",
")",
"{",
"sections",
"add",
"(",
"memory",
"section",
")",
";",
"}",
"else",
"{",
"/",
"/",
"ensure",
"that",
"non",
"-",
"loaded",
"sections",
"are",
"processed",
"after",
"loaded",
"sections",
"/",
"/",
"by",
"inserting",
"them",
"before",
"the",
"loaded",
"sections",
"sections",
"add",
"(",
"next",
"non",
"loaded",
"section",
"insertion",
"index",
"+",
"+",
",",
"memory",
"section",
")",
";",
"}",
"}"
]
|
[
"notifies",
"when",
"child",
"lb",
"status",
"changes"
]
| [
"void",
"on",
"status",
"changed",
"(",
"connectivity",
"state",
"new",
"state",
")",
";"
]
|
[
"create",
"a",
"copy",
"of",
"the",
"chain",
"of",
"data",
"types",
"that",
"eventually",
"lead",
"to",
"a",
"named",
"data",
"type",
"returns",
"a",
"{",
"@",
"link",
"data",
"type",
"#",
"copy",
"(",
"data",
"type",
"manager",
")",
"copy",
"(",
")",
"}",
"of",
"the",
"first",
"named",
"data",
"type",
"found",
"in",
"the",
"pointer",
"array",
"type",
"chain",
",",
"and",
"returns",
"an",
"identical",
"chain",
"of",
"pointer",
"arrays",
"up",
"to",
"the",
"copied",
"named",
"type"
]
| [
"public",
"static",
"data",
"type",
"copy",
"to",
"named",
"base",
"data",
"type",
"(",
"data",
"type",
"data",
"type",
",",
"data",
"type",
"manager",
"dtm",
")",
"{",
"if",
"(",
"data",
"type",
"instanceof",
"pointer",
")",
"{",
"pointer",
"pdt",
"=",
"(",
"pointer",
")",
"data",
"type",
";",
"return",
"new",
"pointer",
"data",
"type",
"(",
"copy",
"to",
"named",
"base",
"data",
"type",
"(",
"pdt",
"get",
"data",
"type",
"(",
")",
",",
"dtm",
")",
",",
"pdt",
"is",
"dynamically",
"sized",
"(",
")",
"?",
"-",
"1",
":",
"pdt",
"get",
"length",
"(",
")",
",",
"dtm",
")",
";",
"}",
"else",
"if",
"(",
"data",
"type",
"instanceof",
"array",
")",
"{",
"array",
"adt",
"=",
"(",
"array",
")",
"data",
"type",
";",
"return",
"new",
"array",
"data",
"type",
"(",
"copy",
"to",
"named",
"base",
"data",
"type",
"(",
"adt",
"get",
"data",
"type",
"(",
")",
",",
"dtm",
")",
",",
"adt",
"get",
"num",
"elements",
"(",
")",
",",
"adt",
"get",
"element",
"length",
"(",
")",
",",
"dtm",
")",
";",
"}",
"else",
"{",
"return",
"data",
"type",
"copy",
"(",
"dtm",
")",
";",
"}",
"}"
]
|
[
"return",
"the",
"first",
"value",
"for",
"the",
"specified",
"native",
"header",
",",
"if",
"present"
]
| [
"public",
"string",
"get",
"first",
"native",
"header",
"(",
"string",
"header",
"name",
")",
"{",
"map",
"<",
"string",
",",
"list",
"<",
"string",
">",
">",
"map",
"=",
"get",
"native",
"headers",
"(",
")",
";",
"if",
"(",
"map",
"!",
"=",
"null",
")",
"{",
"list",
"<",
"string",
">",
"values",
"=",
"map",
"get",
"(",
"header",
"name",
")",
";",
"if",
"(",
"!",
"collection",
"utils",
"is",
"empty",
"(",
"values",
")",
")",
"{",
"return",
"values",
"get",
"(",
"0",
")",
";",
"}",
"}",
"return",
"null",
";",
"}"
]
|
[
"if",
"true",
",",
"then",
"program",
"trees",
"should",
"be",
"readwritten"
]
| [
"public",
"boolean",
"is",
"trees",
"(",
")",
"{",
"return",
"trees",
";",
"}"
]
|
[
"returns",
"an",
"array",
"of",
"the",
"indicated",
"contiguous",
"number",
"of",
"indices",
"starting",
"at",
"0",
"this",
"provides",
"a",
"convenient",
"way",
"to",
"get",
"an",
"array",
"indicating",
"all",
"the",
"operand",
"indices",
"for",
"a",
"particular",
"code",
"unit",
"by",
"specifying",
"its",
"number",
"of",
"operands"
]
| [
"private",
"int",
"[",
"]",
"get",
"all",
"indices",
"(",
"int",
"number",
")",
"{",
"if",
"(",
"number",
"<",
"0",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
")",
";",
"}",
"int",
"[",
"]",
"numbers",
"=",
"new",
"int",
"[",
"number",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"number",
";",
"i",
"+",
"+",
")",
"{",
"numbers",
"[",
"i",
"]",
"=",
"i",
";",
"}",
"return",
"numbers",
";",
"}"
]
|
[
"returns",
"the",
"contents",
"of",
"the",
"{",
"@",
"code",
"-",
"pyversioninfo",
"txt",
"}",
"file",
"that",
"would",
"be",
"produced",
"by",
"running",
"the",
"aspect",
"on",
"the",
"given",
"target"
]
| [
"private",
"string",
"evaluate",
"aspect",
"for",
"(",
"string",
"label",
")",
"throws",
"exception",
"{",
"scratch",
"file",
"(",
"\"",
"asp",
"/",
"build",
"\"",
",",
"\"",
"load",
"(",
"'",
"\"",
"+",
"test",
"constants",
"tools",
"repository",
"+",
"\"",
"/",
"/",
"tools",
"/",
"python",
":",
"srcs",
"version",
"bzl",
"'",
",",
"\"",
",",
"\"",
"'",
"apply",
"find",
"requirements",
"for",
"testing",
"'",
")",
"\"",
",",
"\"",
"apply",
"find",
"requirements",
"for",
"testing",
"(",
"\"",
",",
"\"",
"name",
"=",
"'",
"asp",
"'",
",",
"\"",
",",
"\"",
"target",
"=",
"'",
"\"",
"+",
"label",
"+",
"\"",
"'",
",",
"\"",
",",
"\"",
"out",
"=",
"'",
"out",
"'",
",",
"\"",
",",
"\"",
")",
"\"",
")",
";",
"configured",
"target",
"ct",
"=",
"get",
"configured",
"target",
"(",
"\"",
"/",
"/",
"asp",
"\"",
")",
";",
"assert",
"that",
"(",
"ct",
")",
"is",
"not",
"null",
"(",
")",
";",
"artifact",
"out",
"=",
"get",
"bin",
"artifact",
"(",
"\"",
"out",
"\"",
",",
"ct",
")",
";",
"action",
"action",
"=",
"get",
"generating",
"action",
"(",
"out",
")",
";",
"assert",
"that",
"(",
"action",
")",
"is",
"instance",
"of",
"(",
"file",
"write",
"action",
"class",
")",
";",
"return",
"(",
"(",
"file",
"write",
"action",
")",
"action",
")",
"get",
"file",
"contents",
"(",
")",
";",
"}"
]
|
[
"gets",
"the",
"latitude",
"for",
"the",
"given",
"point"
]
| [
"public",
"static",
"double",
"get",
"latitude",
"(",
"point",
"location",
")",
"{",
"return",
"location",
"get",
"latitude",
"(",
")",
"/",
"coord",
"factor",
";",
"}"
]
|
[
"uploads",
"an",
"image"
]
| [
"public",
"model",
"api",
"response",
"upload",
"file",
"(",
"@",
"path",
"param",
"(",
"\"",
"pet",
"id",
"\"",
")",
"long",
"pet",
"id",
",",
"@",
"multipart",
"(",
"value",
"=",
"\"",
"additional",
"metadata",
"\"",
",",
"required",
"=",
"false",
")",
"string",
"additional",
"metadata",
",",
"@",
"multipart",
"(",
"value",
"=",
"\"",
"file",
"\"",
",",
"required",
"=",
"false",
")",
"attachment",
"file",
"detail",
")",
";"
]
|
[
"get",
"the",
"length",
"of",
"the",
"remote",
"object"
]
| [
"public",
"long",
"get",
"content",
"length",
"(",
"swift",
"object",
"path",
"path",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"get",
"content",
"length",
"(",
"path",
"to",
"u",
"r",
"i",
"(",
"path",
")",
")",
";",
"}"
]
|
[
"make",
"sure",
"we",
"can",
"recover",
"from",
"a",
"frozen",
"engine"
]
| [
"public",
"void",
"test",
"recover",
"from",
"frozen",
"primary",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"index",
"shard",
"index",
"shard",
"=",
"new",
"started",
"shard",
"(",
"true",
")",
";",
"index",
"doc",
"(",
"index",
"shard",
",",
"\"",
"doc",
"\"",
",",
"\"",
"1",
"\"",
")",
";",
"index",
"doc",
"(",
"index",
"shard",
",",
"\"",
"doc",
"\"",
",",
"\"",
"2",
"\"",
")",
";",
"index",
"doc",
"(",
"index",
"shard",
",",
"\"",
"doc",
"\"",
",",
"\"",
"3",
"\"",
")",
";",
"index",
"shard",
"close",
"(",
"\"",
"test",
"\"",
",",
"true",
")",
";",
"final",
"shard",
"routing",
"shard",
"routing",
"=",
"index",
"shard",
"routing",
"entry",
"(",
")",
";",
"index",
"shard",
"frozen",
"shard",
"=",
"reinit",
"shard",
"(",
"index",
"shard",
",",
"shard",
"routing",
"helper",
"init",
"with",
"same",
"id",
"(",
"shard",
"routing",
",",
"shard",
"routing",
"primary",
"(",
")",
"?",
"recovery",
"source",
"existing",
"store",
"recovery",
"source",
"instance",
":",
"recovery",
"source",
"peer",
"recovery",
"source",
"instance",
")",
",",
"index",
"shard",
"index",
"settings",
"(",
")",
"get",
"index",
"metadata",
"(",
")",
",",
"config",
"-",
">",
"new",
"frozen",
"engine",
"(",
"config",
",",
"true",
")",
")",
";",
"recover",
"shard",
"from",
"store",
"(",
"frozen",
"shard",
")",
";",
"assert",
"that",
"(",
"frozen",
"shard",
"get",
"max",
"seq",
"no",
"of",
"updates",
"or",
"deletes",
"(",
")",
",",
"equal",
"to",
"(",
"frozen",
"shard",
"seq",
"no",
"stats",
"(",
")",
"get",
"max",
"seq",
"no",
"(",
")",
")",
")",
";",
"assert",
"doc",
"count",
"(",
"frozen",
"shard",
",",
"3",
")",
";",
"index",
"shard",
"replica",
"=",
"new",
"shard",
"(",
"false",
",",
"settings",
"empty",
",",
"config",
"-",
">",
"new",
"frozen",
"engine",
"(",
"config",
",",
"true",
")",
")",
";",
"recover",
"replica",
"(",
"replica",
",",
"frozen",
"shard",
",",
"true",
")",
";",
"assert",
"doc",
"count",
"(",
"replica",
",",
"3",
")",
";",
"close",
"shards",
"(",
"frozen",
"shard",
",",
"replica",
")",
";",
"}"
]
|
[
"verify",
"quit",
"election",
"terminates",
"connection",
"and",
"there",
"are",
"no",
"new",
"watches",
"next",
"call",
"to",
"join",
"election",
"creates",
"new",
"connection",
"and",
"performs",
"election"
]
| [
"public",
"void",
"test",
"quit",
"election",
"(",
")",
"throws",
"exception",
"{",
"elector",
"join",
"election",
"(",
"data",
")",
";",
"mockito",
"verify",
"(",
"mock",
"z",
"k",
",",
"mockito",
"times",
"(",
"0",
")",
")",
"close",
"(",
")",
";",
"elector",
"quit",
"election",
"(",
"true",
")",
";",
"mockito",
"verify",
"(",
"mock",
"z",
"k",
",",
"mockito",
"times",
"(",
"1",
")",
")",
"close",
"(",
")",
";",
"/",
"/",
"no",
"watches",
"added",
"verify",
"exist",
"call",
"(",
"0",
")",
";",
"byte",
"[",
"]",
"data",
"=",
"new",
"byte",
"[",
"8",
"]",
";",
"elector",
"join",
"election",
"(",
"data",
")",
";",
"/",
"/",
"get",
"new",
"zoo",
"keeper",
"called",
"2",
"times",
"once",
"in",
"constructor",
"and",
"once",
"now",
"assert",
"assert",
"equals",
"(",
"2",
",",
"count",
")",
";",
"elector",
"process",
"result",
"(",
"code",
"nodeexists",
"int",
"value",
"(",
")",
",",
"zk",
"lock",
"name",
",",
"mock",
"z",
"k",
",",
"zk",
"lock",
"name",
")",
";",
"mockito",
"verify",
"(",
"mock",
"app",
",",
"mockito",
"times",
"(",
"1",
")",
")",
"become",
"standby",
"(",
")",
";",
"verify",
"exist",
"call",
"(",
"1",
")",
";",
"}"
]
|
[
"skip",
"through",
"a",
"given",
"stream",
"of",
"edits",
"until",
"the",
"given",
"transaction",
"id",
"is",
"found",
"return",
"the",
"number",
"of",
"bytes",
"that",
"appear",
"prior",
"to",
"the",
"given",
"transaction"
]
| [
"private",
"int",
"find",
"transaction",
"position",
"(",
"byte",
"[",
"]",
"buf",
",",
"long",
"txn",
"id",
")",
"throws",
"i",
"o",
"exception",
"{",
"byte",
"array",
"input",
"stream",
"bais",
"=",
"new",
"byte",
"array",
"input",
"stream",
"(",
"buf",
")",
";",
"f",
"s",
"edit",
"log",
"loader",
"position",
"tracking",
"input",
"stream",
"tracker",
"=",
"new",
"f",
"s",
"edit",
"log",
"loader",
"position",
"tracking",
"input",
"stream",
"(",
"bais",
")",
";",
"f",
"s",
"edit",
"log",
"op",
"reader",
"reader",
"=",
"f",
"s",
"edit",
"log",
"op",
"reader",
"create",
"(",
"new",
"data",
"input",
"stream",
"(",
"tracker",
")",
",",
"tracker",
",",
"layout",
"version",
")",
";",
"long",
"previous",
"pos",
"=",
"0",
";",
"while",
"(",
"reader",
"scan",
"op",
"(",
")",
"<",
"txn",
"id",
")",
"{",
"previous",
"pos",
"=",
"tracker",
"get",
"pos",
"(",
")",
";",
"}",
"/",
"/",
"tracker",
"is",
"backed",
"by",
"a",
"byte",
"[",
"]",
";",
"position",
"cannot",
"go",
"above",
"an",
"integer",
"return",
"(",
"int",
")",
"previous",
"pos",
";",
"}"
]
|
[
"gets",
"the",
"type",
"of",
"the",
"defining",
"class"
]
| [
"public",
"final",
"cst",
"type",
"get",
"defining",
"class",
"(",
")",
"{",
"return",
"defining",
"class",
";",
"}"
]
|
[
"call",
"set",
"value",
"(",
")",
"but",
"expect",
"it",
"to",
"fail"
]
| [
"protected",
"void",
"set",
"value",
"expect",
"error",
"(",
"string",
"expression",
",",
"object",
"value",
")",
"{",
"expression",
"e",
"=",
"parser",
"parse",
"expression",
"(",
"expression",
")",
";",
"assert",
"that",
"(",
"e",
")",
"is",
"not",
"null",
"(",
")",
";",
"if",
"(",
"debug",
")",
"{",
"spel",
"utilities",
"print",
"abstract",
"syntax",
"tree",
"(",
"system",
"out",
",",
"e",
")",
";",
"}",
"standard",
"evaluation",
"context",
"l",
"context",
"=",
"test",
"scenario",
"creator",
"get",
"test",
"evaluation",
"context",
"(",
")",
";",
"assert",
"that",
"exception",
"of",
"type",
"(",
"evaluation",
"exception",
"class",
")",
"is",
"thrown",
"by",
"(",
"(",
")",
"-",
">",
"e",
"set",
"value",
"(",
"l",
"context",
",",
"value",
")",
")",
";",
"}"
]
|
[
"creates",
"a",
"scaled",
"image",
"icon",
"from",
"the",
"given",
"icon",
"with",
"scaling",
"of",
"{",
"@",
"link",
"image",
"#",
"scale",
"area",
"averaging",
"}"
]
| [
"public",
"static",
"image",
"icon",
"get",
"scaled",
"icon",
"(",
"icon",
"icon",
",",
"int",
"width",
",",
"int",
"height",
")",
"{",
"return",
"new",
"scaled",
"image",
"icon",
"wrapper",
"(",
"icon",
",",
"width",
",",
"height",
")",
";",
"}"
]
|
[
"set",
"the",
"name",
"of",
"the",
"default",
"{",
"@",
"code",
"servlet",
"}",
"also",
"{",
"@",
"link",
"#",
"unregister",
"named",
"dispatcher",
"unregisters",
"}",
"the",
"current",
"default",
"{",
"@",
"link",
"request",
"dispatcher",
"}",
"and",
"{",
"@",
"link",
"#",
"register",
"named",
"dispatcher",
"replaces",
"}",
"it",
"with",
"a",
"{",
"@",
"link",
"mock",
"request",
"dispatcher",
"}",
"for",
"the",
"provided",
"{",
"@",
"code",
"default",
"servlet",
"name",
"}"
]
| [
"public",
"void",
"set",
"default",
"servlet",
"name",
"(",
"string",
"default",
"servlet",
"name",
")",
"{",
"assert",
"has",
"text",
"(",
"default",
"servlet",
"name",
",",
"\"",
"default",
"servlet",
"name",
"must",
"not",
"be",
"null",
"or",
"empty",
"\"",
")",
";",
"unregister",
"named",
"dispatcher",
"(",
"this",
"default",
"servlet",
"name",
")",
";",
"this",
"default",
"servlet",
"name",
"=",
"default",
"servlet",
"name",
";",
"register",
"named",
"dispatcher",
"(",
"this",
"default",
"servlet",
"name",
",",
"new",
"mock",
"request",
"dispatcher",
"(",
"this",
"default",
"servlet",
"name",
")",
")",
";",
"}"
]
|
[
"validates",
"that",
"no",
"class",
"cast",
"exception",
"happens",
"should",
"not",
"fail",
"e",
"g",
"like",
"in",
"flink",
"-",
"8255"
]
| [
"public",
"void",
"test",
"row",
"type",
"info",
"(",
")",
"{",
"type",
"information",
"<",
"?",
">",
"[",
"]",
"type",
"list",
"=",
"new",
"type",
"information",
"<",
"?",
">",
"[",
"]",
"{",
"new",
"row",
"type",
"info",
"(",
"basic",
"type",
"info",
"short",
"type",
"info",
",",
"basic",
"type",
"info",
"big",
"dec",
"type",
"info",
")",
"}",
";",
"string",
"[",
"]",
"field",
"names",
"=",
"new",
"string",
"[",
"]",
"{",
"\"",
"row",
"\"",
"}",
";",
"row",
"type",
"info",
"row",
"type",
"info",
"=",
"new",
"row",
"type",
"info",
"(",
"type",
"list",
",",
"field",
"names",
")",
";",
"field",
"accessor",
"f",
"=",
"field",
"accessor",
"factory",
"get",
"accessor",
"(",
"row",
"type",
"info",
",",
"\"",
"row",
"0",
"\"",
",",
"null",
")",
";",
"}"
]
|
[
"assert",
"the",
"extracted",
"body",
"with",
"a",
"{",
"@",
"link",
"matcher",
"}"
]
| [
"<",
"t",
"extends",
"s",
">",
"t",
"value",
"(",
"matcher",
"<",
"?",
"super",
"b",
">",
"matcher",
")",
";"
]
|
[
"compares",
"reference",
"from",
"program",
"1",
"with",
"reference",
"from",
"program",
"2",
"to",
"see",
"if",
"they",
"are",
"equivalent"
]
| [
"static",
"boolean",
"equivalent",
"references",
"(",
"program",
"p",
"1",
",",
"program",
"p",
"2",
",",
"reference",
"ref",
"1",
",",
"reference",
"ref",
"2",
")",
"{",
"if",
"(",
"ref",
"1",
"=",
"=",
"ref",
"2",
")",
"{",
"return",
"true",
";",
"}",
"if",
"(",
"ref",
"1",
"=",
"=",
"null",
"|",
"|",
"ref",
"2",
"=",
"=",
"null",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"ref",
"1",
"get",
"operand",
"index",
"(",
")",
"!",
"=",
"ref",
"2",
"get",
"operand",
"index",
"(",
")",
"|",
"|",
"ref",
"1",
"get",
"reference",
"type",
"(",
")",
"!",
"=",
"ref",
"2",
"get",
"reference",
"type",
"(",
")",
"|",
"|",
"/",
"/",
"ref",
"1",
"get",
"source",
"(",
")",
"!",
"=",
"ref",
"2",
"get",
"source",
"(",
")",
"|",
"|",
"/",
"/",
"ignore",
"source",
"type",
"since",
"we",
"can",
"'",
"t",
"change",
"it",
"anyway",
"ref",
"1",
"is",
"primary",
"(",
")",
"!",
"=",
"ref",
"2",
"is",
"primary",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"address",
"from",
"addr",
"1",
"=",
"ref",
"1",
"get",
"from",
"address",
"(",
")",
";",
"address",
"from",
"addr",
"2",
"=",
"ref",
"2",
"get",
"from",
"address",
"(",
")",
";",
"address",
"from",
"addr",
"2",
"as",
"p",
"1",
"=",
"simple",
"diff",
"utility",
"get",
"compatible",
"address",
"(",
"p",
"2",
",",
"from",
"addr",
"2",
",",
"p",
"1",
")",
";",
"if",
"(",
"!",
"from",
"addr",
"1",
"equals",
"(",
"from",
"addr",
"2",
"as",
"p",
"1",
")",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"!",
"ref",
"1",
"is",
"external",
"reference",
"(",
")",
")",
"{",
"address",
"to",
"addr",
"1",
"=",
"ref",
"1",
"get",
"to",
"address",
"(",
")",
";",
"address",
"to",
"addr",
"2",
"=",
"ref",
"2",
"get",
"to",
"address",
"(",
")",
";",
"address",
"to",
"addr",
"2",
"as",
"p",
"1",
"=",
"simple",
"diff",
"utility",
"get",
"compatible",
"address",
"(",
"p",
"2",
",",
"to",
"addr",
"2",
",",
"p",
"1",
")",
";",
"if",
"(",
"!",
"to",
"addr",
"1",
"equals",
"(",
"to",
"addr",
"2",
"as",
"p",
"1",
")",
")",
"{",
"return",
"false",
";",
"}",
"}",
"symbol",
"p",
"1",
"symbol",
"=",
"p",
"1",
"get",
"symbol",
"table",
"(",
")",
"get",
"symbol",
"(",
"ref",
"1",
"get",
"symbol",
"i",
"d",
"(",
")",
")",
";",
"symbol",
"p",
"2",
"symbol",
"=",
"p",
"2",
"get",
"symbol",
"table",
"(",
")",
"get",
"symbol",
"(",
"ref",
"2",
"get",
"symbol",
"i",
"d",
"(",
")",
")",
";",
"if",
"(",
"!",
"program",
"diff",
"equivalent",
"symbols",
"(",
"p",
"1",
",",
"p",
"2",
",",
"p",
"1",
"symbol",
",",
"p",
"2",
"symbol",
")",
")",
"{",
"return",
"false",
";",
"}",
"/",
"/",
"entry",
"point",
"reference",
"if",
"(",
"ref",
"1",
"is",
"entry",
"point",
"reference",
"(",
")",
")",
"{",
"return",
"ref",
"2",
"is",
"entry",
"point",
"reference",
"(",
")",
";",
"}",
"/",
"/",
"external",
"reference",
"if",
"(",
"ref",
"1",
"is",
"external",
"reference",
"(",
")",
")",
"{",
"if",
"(",
"!",
"ref",
"2",
"is",
"external",
"reference",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"external",
"reference",
"ext",
"ref",
"1",
"=",
"(",
"external",
"reference",
")",
"ref",
"1",
";",
"external",
"reference",
"ext",
"ref",
"2",
"=",
"(",
"external",
"reference",
")",
"ref",
"2",
";",
"external",
"location",
"ext",
"loc",
"1",
"=",
"ext",
"ref",
"1",
"get",
"external",
"location",
"(",
")",
";",
"external",
"location",
"ext",
"loc",
"2",
"=",
"ext",
"ref",
"2",
"get",
"external",
"location",
"(",
")",
";",
"return",
"is",
"equivalent",
"(",
"ext",
"loc",
"1",
",",
"ext",
"loc",
"2",
")",
";",
"}",
"/",
"/",
"offset",
"reference",
"if",
"(",
"ref",
"1",
"is",
"offset",
"reference",
"(",
")",
")",
"{",
"if",
"(",
"!",
"ref",
"2",
"is",
"offset",
"reference",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"offset",
"reference",
"offset",
"ref",
"1",
"=",
"(",
"offset",
"reference",
")",
"ref",
"1",
";",
"offset",
"reference",
"offset",
"ref",
"2",
"=",
"(",
"offset",
"reference",
")",
"ref",
"2",
";",
"return",
"offset",
"ref",
"1",
"get",
"offset",
"(",
")",
"=",
"=",
"offset",
"ref",
"2",
"get",
"offset",
"(",
")",
";",
"}",
"/",
"/",
"shifted",
"reference",
"if",
"(",
"ref",
"1",
"is",
"shifted",
"reference",
"(",
")",
")",
"{",
"if",
"(",
"!",
"ref",
"2",
"is",
"shifted",
"reference",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"shifted",
"reference",
"shifted",
"ref",
"1",
"=",
"(",
"shifted",
"reference",
")",
"ref",
"1",
";",
"shifted",
"reference",
"shifted",
"ref",
"2",
"=",
"(",
"shifted",
"reference",
")",
"ref",
"2",
";",
"return",
"shifted",
"ref",
"1",
"get",
"shift",
"(",
")",
"=",
"=",
"shifted",
"ref",
"2",
"get",
"shift",
"(",
")",
";",
"}",
"/",
"/",
"stack",
"reference",
"if",
"(",
"ref",
"1",
"is",
"stack",
"reference",
"(",
")",
")",
"{",
"if",
"(",
"!",
"ref",
"2",
"is",
"stack",
"reference",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"stack",
"reference",
"stack",
"ref",
"1",
"=",
"(",
"stack",
"reference",
")",
"ref",
"1",
";",
"stack",
"reference",
"stack",
"ref",
"2",
"=",
"(",
"stack",
"reference",
")",
"ref",
"2",
";",
"return",
"stack",
"ref",
"1",
"get",
"stack",
"offset",
"(",
")",
"=",
"=",
"stack",
"ref",
"2",
"get",
"stack",
"offset",
"(",
")",
";",
"}",
"/",
"/",
"register",
"reference",
"if",
"(",
"ref",
"1",
"is",
"register",
"reference",
"(",
")",
")",
"{",
"if",
"(",
"!",
"ref",
"2",
"is",
"register",
"reference",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"}",
"/",
"/",
"memory",
"reference",
"if",
"(",
"ref",
"1",
"is",
"memory",
"reference",
"(",
")",
")",
"{",
"return",
"ref",
"2",
"is",
"memory",
"reference",
"(",
")",
";",
"}",
"return",
"true",
";",
"}"
]
|
[
"fetch",
"an",
"animation",
"from",
"an",
"http",
"url",
"once",
"it",
"is",
"downloaded",
"once",
",",
"lottie",
"will",
"cache",
"the",
"file",
"to",
"disk",
"for",
"future",
"use",
"because",
"of",
"this",
",",
"you",
"may",
"call",
"`",
"from",
"url",
"`",
"ahead",
"of",
"time",
"to",
"warm",
"the",
"cache",
"if",
"you",
"think",
"you",
"might",
"need",
"an",
"animation",
"in",
"the",
"future"
]
| [
"public",
"static",
"lottie",
"result",
"<",
"lottie",
"composition",
">",
"from",
"url",
"sync",
"(",
"context",
"context",
",",
"string",
"url",
",",
"@",
"nullable",
"string",
"cache",
"key",
")",
"{",
"lottie",
"result",
"<",
"lottie",
"composition",
">",
"result",
"=",
"l",
"network",
"fetcher",
"(",
"context",
")",
"fetch",
"sync",
"(",
"url",
",",
"cache",
"key",
")",
";",
"if",
"(",
"cache",
"key",
"!",
"=",
"null",
"&",
"&",
"result",
"get",
"value",
"(",
")",
"!",
"=",
"null",
")",
"{",
"lottie",
"composition",
"cache",
"get",
"instance",
"(",
")",
"put",
"(",
"cache",
"key",
",",
"result",
"get",
"value",
"(",
")",
")",
";",
"}",
"return",
"result",
";",
"}"
]
|
[
"gets",
"the",
"minimum",
"retained",
"sequence",
"number",
"for",
"this",
"engine"
]
| [
"public",
"long",
"get",
"min",
"retained",
"seq",
"no",
"(",
")",
"{",
"return",
"get",
"engine",
"(",
")",
"get",
"min",
"retained",
"seq",
"no",
"(",
")",
";",
"}"
]
|
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"the",
"renderer",
"can",
"render",
"the",
"given",
"{",
"@",
"link",
"view",
"}"
]
| [
"boolean",
"is",
"renderable",
"(",
"view",
"view",
")",
";"
]
|
[
"returns",
"a",
"string",
"containing",
"the",
"attribute",
"signature",
"for",
"this",
"rule",
"with",
"html",
"links",
"to",
"the",
"attributes"
]
| [
"public",
"string",
"get",
"attribute",
"signature",
"(",
")",
"{",
"string",
"builder",
"sb",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"sb",
"append",
"(",
"string",
"format",
"(",
"\"",
"%",
"s",
"(",
"<",
"a",
"href",
"=",
"\\",
"\"",
"#",
"%",
"s",
"name",
"\\",
"\"",
">",
"name",
"<",
"/",
"a",
">",
",",
"\"",
",",
"rule",
"name",
",",
"rule",
"name",
")",
")",
";",
"int",
"i",
"=",
"0",
";",
"for",
"(",
"rule",
"documentation",
"attribute",
"attribute",
"doc",
":",
"attributes",
")",
"{",
"string",
"attr",
"name",
"=",
"attribute",
"doc",
"get",
"attribute",
"name",
"(",
")",
";",
"/",
"/",
"generate",
"the",
"link",
"for",
"the",
"attribute",
"documentation",
"if",
"(",
"attribute",
"doc",
"is",
"common",
"type",
"(",
")",
")",
"{",
"sb",
"append",
"(",
"string",
"format",
"(",
"\"",
"<",
"a",
"href",
"=",
"\\",
"\"",
"%",
"s",
"#",
"%",
"s",
"%",
"s",
"\\",
"\"",
">",
"%",
"s",
"<",
"/",
"a",
">",
"\"",
",",
"common",
"definitions",
"page",
",",
"attribute",
"doc",
"get",
"generated",
"in",
"rule",
"(",
"rule",
"name",
")",
"to",
"lower",
"case",
"(",
")",
",",
"attr",
"name",
",",
"attr",
"name",
")",
")",
";",
"}",
"else",
"{",
"sb",
"append",
"(",
"string",
"format",
"(",
"\"",
"<",
"a",
"href",
"=",
"\\",
"\"",
"#",
"%",
"s",
"%",
"s",
"\\",
"\"",
">",
"%",
"s",
"<",
"/",
"a",
">",
"\"",
",",
"attribute",
"doc",
"get",
"generated",
"in",
"rule",
"(",
"rule",
"name",
")",
"to",
"lower",
"case",
"(",
")",
",",
"attr",
"name",
",",
"attr",
"name",
")",
")",
";",
"}",
"if",
"(",
"i",
"<",
"attributes",
"size",
"(",
")",
"-",
"1",
")",
"{",
"sb",
"append",
"(",
"\"",
",",
"\"",
")",
";",
"}",
"else",
"{",
"sb",
"append",
"(",
"\"",
")",
"\"",
")",
";",
"}",
"i",
"+",
"+",
";",
"}",
"return",
"sb",
"to",
"string",
"(",
")",
";",
"}"
]
|
[
"type",
"information",
"of",
"the",
"literal",
"value",
"e",
"g",
"types",
"boolean"
]
| [
"public",
"literal",
"value",
"of",
"(",
"type",
"information",
"<",
"?",
">",
"type",
"info",
")",
"{",
"preconditions",
"check",
"not",
"null",
"(",
"type",
"info",
",",
"\"",
"type",
"information",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"this",
"type",
"info",
"=",
"type",
"string",
"utils",
"write",
"type",
"info",
"(",
"type",
"info",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"clean",
"all",
"patch",
"files"
]
| [
"public",
"void",
"clean",
"patch",
"(",
")",
"{",
"share",
"tinker",
"log",
"e",
"(",
"tag",
",",
"\"",
"[",
"-",
"]",
"ignore",
"this",
"invocation",
"since",
"i",
"'",
"m",
"no",
"-",
"op",
"version",
"\"",
")",
";",
"}"
]
|
[
"setter",
"for",
"use",
"native",
"code",
"option"
]
| [
"public",
"static",
"void",
"set",
"use",
"native",
"code",
"(",
"boolean",
"use",
"native",
"code",
")",
"{",
"s",
"use",
"native",
"code",
"=",
"use",
"native",
"code",
";",
"}"
]
|
[
"convenience",
"method",
"to",
"compute",
"a",
"fingerprint",
"on",
"a",
"subset",
"of",
"a",
"byte",
"array"
]
| [
"private",
"static",
"long",
"fingerprint",
"(",
"byte",
"[",
"]",
"bytes",
",",
"int",
"length",
")",
"{",
"return",
"hash",
"fn",
"hash",
"bytes",
"(",
"bytes",
",",
"0",
",",
"length",
")",
"as",
"long",
"(",
")",
";",
"}"
]
|
[
"the",
"value",
"assigned",
"to",
"this",
"plural",
"<",
"code",
">",
"optional",
"aapt",
"pb",
"item",
"item",
"=",
"4",
";",
"<",
"code",
">"
]
| [
"private",
"void",
"set",
"item",
"(",
"com",
"android",
"aapt",
"resources",
"item",
"builder",
"builder",
"for",
"value",
")",
"{",
"item",
"=",
"builder",
"for",
"value",
"build",
"(",
")",
";",
"bit",
"field",
"0",
"|",
"=",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"8",
";",
"}"
]
|
[
"sets",
"the",
"<",
"code",
">",
"map",
"string",
"<",
"code",
">",
"property"
]
| [
"public",
"void",
"set",
"map",
"string",
"(",
"map",
"<",
"string",
",",
"string",
">",
"map",
"string",
")",
"{",
"this",
"map",
"string",
"=",
"map",
"string",
";",
"}"
]
|
[
"write",
"property",
"and",
"its",
"attributes",
"as",
"json",
"format",
"to",
"given",
"{",
"@",
"link",
"json",
"generator",
"}"
]
| [
"private",
"static",
"void",
"append",
"j",
"s",
"o",
"n",
"property",
"(",
"json",
"generator",
"json",
"gen",
",",
"configuration",
"config",
",",
"string",
"name",
",",
"config",
"redactor",
"redactor",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"/",
"skip",
"writing",
"if",
"given",
"property",
"name",
"is",
"empty",
"or",
"null",
"if",
"(",
"!",
"strings",
"is",
"null",
"or",
"empty",
"(",
"name",
")",
"&",
"&",
"json",
"gen",
"!",
"=",
"null",
")",
"{",
"json",
"gen",
"write",
"start",
"object",
"(",
")",
";",
"json",
"gen",
"write",
"string",
"field",
"(",
"\"",
"key",
"\"",
",",
"name",
")",
";",
"json",
"gen",
"write",
"string",
"field",
"(",
"\"",
"value",
"\"",
",",
"redactor",
"redact",
"(",
"name",
",",
"config",
"get",
"(",
"name",
")",
")",
")",
";",
"json",
"gen",
"write",
"boolean",
"field",
"(",
"\"",
"is",
"final",
"\"",
",",
"config",
"final",
"parameters",
"contains",
"(",
"name",
")",
")",
";",
"string",
"[",
"]",
"resources",
"=",
"config",
"updating",
"resource",
"!",
"=",
"null",
"?",
"config",
"updating",
"resource",
"get",
"(",
"name",
")",
":",
"null",
";",
"string",
"resource",
"=",
"unknown",
"resource",
";",
"if",
"(",
"resources",
"!",
"=",
"null",
"&",
"&",
"resources",
"length",
">",
"0",
")",
"{",
"resource",
"=",
"resources",
"[",
"0",
"]",
";",
"}",
"json",
"gen",
"write",
"string",
"field",
"(",
"\"",
"resource",
"\"",
",",
"resource",
")",
";",
"json",
"gen",
"write",
"end",
"object",
"(",
")",
";",
"}",
"}"
]
|
[
"re",
"-",
"create",
"the",
"given",
"mime",
"type",
"as",
"a",
"media",
"type"
]
| [
"public",
"static",
"media",
"type",
"as",
"media",
"type",
"(",
"mime",
"type",
"mime",
"type",
")",
"{",
"if",
"(",
"mime",
"type",
"instanceof",
"media",
"type",
")",
"{",
"return",
"(",
"media",
"type",
")",
"mime",
"type",
";",
"}",
"return",
"new",
"media",
"type",
"(",
"mime",
"type",
"get",
"type",
"(",
")",
",",
"mime",
"type",
"get",
"subtype",
"(",
")",
",",
"mime",
"type",
"get",
"parameters",
"(",
")",
")",
";",
"}"
]
|
[
"return",
"the",
"property",
"value",
"associated",
"with",
"the",
"given",
"key",
"(",
"never",
"{",
"@",
"code",
"null",
"}",
")"
]
| [
"string",
"get",
"required",
"property",
"(",
"string",
"key",
")",
"throws",
"illegal",
"state",
"exception",
";"
]
|
[
"gets",
"resource",
"id"
]
| [
"public",
"string",
"get",
"resource",
"id",
"(",
")",
"{",
"return",
"resource",
"id",
";",
"}"
]
|
[
"set",
"up",
"the",
"acl",
"for",
"the",
"user",
"<",
"b",
">",
"important",
":",
"this",
"must",
"run",
"client",
"-",
"side",
"as",
"it",
"needs",
"to",
"know",
"the",
"id",
":",
"pass",
"tuple",
"for",
"a",
"user",
"<",
"b",
">"
]
| [
"public",
"list",
"<",
"acl",
">",
"acls",
"for",
"user",
"(",
"string",
"username",
",",
"int",
"perms",
")",
"throws",
"i",
"o",
"exception",
"{",
"list",
"<",
"acl",
">",
"client",
"a",
"c",
"ls",
"=",
"get",
"client",
"acls",
"(",
")",
";",
"registry",
"security",
"security",
"=",
"get",
"registry",
"security",
"(",
")",
";",
"if",
"(",
"security",
"is",
"secure",
"registry",
"(",
")",
")",
"{",
"client",
"a",
"c",
"ls",
"add",
"(",
"security",
"create",
"a",
"c",
"lfrom",
"username",
"(",
"username",
",",
"perms",
")",
")",
";",
"}",
"return",
"client",
"a",
"c",
"ls",
";",
"}"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.