docstring_tokens
list | code_tokens
list |
|---|---|
[
"find",
"the",
"fields",
"constant",
"that",
"matches",
"name",
",",
"or",
"null",
"if",
"its",
"not",
"found"
]
| [
"public",
"static",
"fields",
"find",
"by",
"name",
"(",
"string",
"name",
")",
"{",
"return",
"by",
"name",
"get",
"(",
"name",
")",
";",
"}"
]
|
[
"returns",
"the",
"total",
"number",
"of",
"compressed",
"bytes",
"input",
"so",
"far"
]
| [
"public",
"synchronized",
"long",
"get",
"bytes",
"read",
"(",
")",
"{",
"check",
"stream",
"(",
")",
";",
"return",
"get",
"bytes",
"read",
"(",
"stream",
")",
";",
"}"
]
|
[
"add",
"the",
"given",
"handler",
"to",
"the",
"end",
"of",
"the",
"list",
"of",
"handlers"
]
| [
"public",
"void",
"add",
"handler",
"at",
"end",
"(",
"handler",
"handler",
")",
"{",
"handlers",
"add",
"handler",
"(",
"handler",
")",
";",
"}"
]
|
[
"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",
"\"",
")",
";",
"}"
]
|
[
"returns",
"a",
"copy",
"of",
"{",
"@",
"code",
"this",
"}",
"with",
"the",
"seek",
"table",
"replaced",
"by",
"the",
"one",
"given"
]
| [
"public",
"flac",
"stream",
"metadata",
"copy",
"with",
"seek",
"table",
"(",
"@",
"nullable",
"seek",
"table",
"seek",
"table",
")",
"{",
"return",
"new",
"flac",
"stream",
"metadata",
"(",
"min",
"block",
"size",
"samples",
",",
"max",
"block",
"size",
"samples",
",",
"min",
"frame",
"size",
",",
"max",
"frame",
"size",
",",
"sample",
"rate",
",",
"channels",
",",
"bits",
"per",
"sample",
",",
"total",
"samples",
",",
"seek",
"table",
",",
"metadata",
")",
";",
"}"
]
|
[
"regression",
"test",
"to",
"avoid",
"a",
"potential",
"race",
"condition",
"in",
"{",
"@",
"link",
"action",
"execution",
"function",
"}",
"the",
"test",
"ensures",
"that",
"when",
"action",
"execution",
"function",
"executes",
"a",
"skyframe",
"-",
"aware",
"action",
"(",
"implementor",
"of",
"{",
"@",
"link",
"skyframe",
"aware",
"action",
"}",
")",
",",
"action",
"execution",
"function",
"first",
"requests",
"the",
"inputs",
"of",
"the",
"action",
"and",
"ensures",
"they",
"are",
"built",
"before",
"requesting",
"any",
"of",
"its",
"skyframe",
"dependencies",
"this",
"strict",
"ordering",
"is",
"very",
"important",
"to",
"avoid",
"the",
"race",
"condition",
",",
"which",
"could",
"arise",
"if",
"the",
"compute",
"method",
"were",
"too",
"eager",
"to",
"request",
"all",
"dependencies",
":",
"request",
"input",
"files",
"but",
"even",
"if",
"some",
"are",
"missing",
",",
"request",
"also",
"the",
"skyframe",
"-",
"dependencies",
"the",
"race",
"is",
"described",
"in",
"this",
"method",
"'",
"s",
"body"
]
| [
"public",
"void",
"test",
"race",
"condition",
"between",
"input",
"acquisition",
"and",
"skyframe",
"deps",
"(",
")",
"throws",
"exception",
"{",
"/",
"/",
"sequence",
"of",
"events",
"on",
"threads",
"a",
"and",
"b",
",",
"showing",
"sky",
"functions",
"and",
"requested",
"sky",
"keys",
",",
"leading",
"/",
"/",
"to",
"an",
"inconsistent",
"filesystem",
"exception",
":",
"/",
"/",
"/",
"/",
"[",
"thread",
"a",
"]",
"|",
"[",
"thread",
"b",
"]",
"/",
"/",
"action",
"execution",
"function",
"(",
"gen",
"2",
"action",
":",
"|",
"idle",
"/",
"/",
"genfiles",
"/",
"gen",
"1",
"-",
">",
"genfiles",
"/",
"foo",
"/",
"bar",
"/",
"gen",
"2",
")",
"|",
"/",
"/",
"artifact",
":",
"genfiles",
"/",
"gen",
"1",
"|",
"/",
"/",
"mock",
"value",
":",
"dummy",
"argument",
"|",
"/",
"/",
"env",
"values",
"missing",
"(",
")",
":",
"yes",
"=",
"=",
">",
"return",
"|",
"/",
"/",
"|",
"/",
"/",
"artifact",
"function",
"(",
"genfiles",
"/",
"gen",
"1",
")",
"|",
"mock",
"function",
"(",
")",
"/",
"/",
"configured",
"target",
":",
"/",
"/",
"foo",
":",
"gen",
"1",
"|",
"file",
":",
"genfiles",
"/",
"foo",
"/",
"/",
"action",
"execution",
":",
"gen",
"1",
"action",
"|",
"env",
"values",
"missing",
"(",
")",
":",
"yes",
"=",
"=",
">",
"return",
"/",
"/",
"env",
"values",
"missing",
"(",
")",
":",
"yes",
"=",
"=",
">",
"return",
"|",
"/",
"/",
"|",
"file",
"function",
"(",
"genfiles",
"/",
"foo",
")",
"/",
"/",
"action",
"execution",
"function",
"(",
"gen",
"1",
"action",
")",
"|",
"file",
":",
"genfiles",
"/",
"/",
"artifact",
":",
"genfiles",
"/",
"gen",
"0",
"|",
"env",
"values",
"missing",
"(",
")",
":",
"yes",
"=",
"=",
">",
"return",
"/",
"/",
"env",
"values",
"missing",
"(",
")",
":",
"yes",
"=",
"=",
">",
"return",
"|",
"/",
"/",
"|",
"file",
"function",
"(",
"genfiles",
")",
"/",
"/",
"artifact",
"function",
"(",
"genfiles",
"/",
"gen",
"0",
")",
"|",
"file",
"state",
":",
"genfiles",
"/",
"/",
"configured",
"target",
":",
"/",
"/",
"foo",
":",
"gen",
"0",
"|",
"env",
"values",
"missing",
"(",
")",
":",
"yes",
"=",
"=",
">",
"return",
"/",
"/",
"action",
"execution",
":",
"gen",
"0",
"action",
"|",
"/",
"/",
"env",
"values",
"missing",
"(",
")",
":",
"yes",
"=",
"=",
">",
"return",
"|",
"file",
"state",
"function",
"(",
"genfiles",
")",
"/",
"/",
"|",
"stat",
"genfiles",
"/",
"/",
"action",
"execution",
"function",
"(",
"gen",
"0",
"action",
")",
"|",
"return",
"file",
"state",
"value",
":",
"non",
"-",
"existent",
"/",
"/",
"create",
"output",
"directory",
":",
"genfiles",
"|",
"/",
"/",
"working",
"|",
"file",
"function",
"(",
"genfiles",
"/",
"foo",
")",
"/",
"/",
"|",
"file",
":",
"genfiles",
"/",
"/",
"|",
"file",
"state",
":",
"genfiles",
"/",
"foo",
"/",
"/",
"|",
"env",
"values",
"missing",
"(",
")",
":",
"yes",
"=",
"=",
">",
"return",
"/",
"/",
"|",
"/",
"/",
"|",
"file",
"state",
"function",
"(",
"genfiles",
"/",
"foo",
")",
"/",
"/",
"|",
"stat",
"genfiles",
"/",
"foo",
"/",
"/",
"|",
"return",
"file",
"state",
"value",
":",
"non",
"-",
"existent",
"/",
"/",
"|",
"/",
"/",
"done",
",",
"created",
"genfiles",
"/",
"gen",
"0",
"|",
"file",
"function",
"(",
"genfiles",
"/",
"foo",
")",
"/",
"/",
"return",
"action",
"execution",
"value",
"(",
"gen",
"0",
"action",
")",
"|",
"file",
":",
"genfiles",
"/",
"/",
"|",
"file",
"state",
":",
"genfiles",
"/",
"foo",
"/",
"/",
"artifact",
"function",
"(",
"genfiles",
"/",
"gen",
"0",
")",
"|",
"return",
"file",
"value",
"(",
"genfiles",
"/",
"foo",
":",
"non",
"-",
"existent",
")",
"/",
"/",
"configured",
"target",
":",
"/",
"/",
"foo",
":",
"gen",
"0",
"|",
"/",
"/",
"action",
"execution",
":",
"gen",
"0",
"action",
"|",
"mock",
"function",
"(",
")",
"/",
"/",
"return",
"artifact",
"sky",
"key",
"(",
"genfiles",
"/",
"gen",
"0",
")",
"|",
"file",
":",
"genfiles",
"/",
"foo",
"/",
"/",
"|",
"file",
":",
"genfiles",
"/",
"foo",
"/",
"bar",
"/",
"gen",
"1",
"/",
"/",
"action",
"execution",
"function",
"(",
"gen",
"1",
"action",
")",
"|",
"env",
"values",
"missing",
"(",
")",
":",
"yes",
"=",
"=",
">",
"return",
"/",
"/",
"artifact",
":",
"genfiles",
"/",
"gen",
"0",
"|",
"/",
"/",
"create",
"output",
"directory",
":",
"genfiles",
"/",
"foo",
"/",
"bar",
"|",
"file",
"function",
"(",
"genfiles",
"/",
"foo",
"/",
"bar",
"/",
"gen",
"1",
")",
"/",
"/",
"done",
",",
"created",
"genfiles",
"/",
"foo",
"/",
"bar",
"/",
"gen",
"1",
"|",
"file",
":",
"genfiles",
"/",
"foo",
"/",
"bar",
"/",
"/",
"return",
"action",
"execution",
"value",
"(",
"gen",
"1",
"action",
")",
"|",
"env",
"values",
"missing",
"(",
")",
":",
"yes",
"=",
"=",
">",
"return",
"/",
"/",
"|",
"/",
"/",
"idle",
"|",
"file",
"function",
"(",
"genfiles",
"/",
"foo",
"/",
"bar",
")",
"/",
"/",
"|",
"file",
":",
"genfiles",
"/",
"foo",
"/",
"/",
"|",
"file",
"state",
":",
"genfiles",
"/",
"foo",
"/",
"bar",
"/",
"/",
"|",
"env",
"values",
"missing",
"(",
")",
":",
"yes",
"=",
"=",
">",
"return",
"/",
"/",
"|",
"/",
"/",
"|",
"file",
"state",
"function",
"(",
"genfiles",
"/",
"foo",
"/",
"bar",
")",
"/",
"/",
"|",
"stat",
"genfiles",
"/",
"foo",
"/",
"bar",
"/",
"/",
"|",
"return",
"file",
"state",
"value",
":",
"directory",
"/",
"/",
"|",
"/",
"/",
"|",
"file",
"function",
"(",
"genfiles",
"/",
"foo",
"/",
"bar",
")",
"/",
"/",
"|",
"file",
":",
"genfiles",
"/",
"foo",
"/",
"/",
"|",
"file",
"state",
":",
"genfiles",
"/",
"foo",
"/",
"bar",
"/",
"/",
"|",
"throw",
"inconsistent",
"filesystem",
"exception",
":",
"/",
"/",
"|",
"genfiles",
"/",
"foo",
"doesn",
"'",
"t",
"exist",
"but",
"/",
"/",
"|",
"genfiles",
"/",
"foo",
"/",
"bar",
"does",
"!",
"artifact",
"gen",
"file",
"1",
"=",
"create",
"derived",
"artifact",
"(",
"\"",
"foo",
"/",
"bar",
"/",
"gen",
"1",
"txt",
"\"",
")",
";",
"artifact",
"gen",
"file",
"2",
"=",
"create",
"derived",
"artifact",
"(",
"\"",
"gen",
"2",
"txt",
"\"",
")",
";",
"register",
"action",
"(",
"new",
"single",
"output",
"action",
"(",
"null",
",",
"gen",
"file",
"1",
")",
"{",
"@",
"override",
"public",
"action",
"result",
"execute",
"(",
"action",
"execution",
"context",
"action",
"execution",
"context",
")",
"throws",
"action",
"execution",
"exception",
",",
"interrupted",
"exception",
"{",
"write",
"output",
"(",
"null",
",",
"\"",
"gen",
"1",
"\"",
")",
";",
"return",
"action",
"result",
"empty",
";",
"}",
"}",
")",
";",
"register",
"action",
"(",
"new",
"single",
"output",
"skyframe",
"aware",
"action",
"(",
"gen",
"file",
"1",
",",
"gen",
"file",
"2",
")",
"{",
"@",
"override",
"public",
"immutable",
"list",
"<",
"sky",
"key",
">",
"get",
"direct",
"skyframe",
"dependencies",
"(",
")",
"{",
"return",
"immutable",
"list",
"of",
"(",
")",
";",
"}",
"@",
"override",
"public",
"object",
"process",
"skyframe",
"values",
"(",
"immutable",
"list",
"<",
"?",
"extends",
"sky",
"key",
">",
"keys",
",",
"map",
"<",
"sky",
"key",
",",
"value",
"or",
"exception",
"<",
"i",
"o",
"exception",
">",
">",
"values",
",",
"boolean",
"values",
"missing",
")",
"{",
"assert",
"that",
"(",
"keys",
")",
"is",
"empty",
"(",
")",
";",
"assert",
"that",
"(",
"values",
")",
"is",
"empty",
"(",
")",
";",
"assert",
"that",
"(",
"values",
"missing",
")",
"is",
"false",
"(",
")",
";",
"return",
"null",
";",
"}",
"@",
"override",
"public",
"immutable",
"graph",
"<",
"sky",
"key",
">",
"get",
"skyframe",
"dependencies",
"for",
"rewinding",
"(",
"sky",
"key",
"self",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
")",
";",
"}",
"@",
"override",
"public",
"action",
"result",
"execute",
"(",
"action",
"execution",
"context",
"action",
"execution",
"context",
")",
"throws",
"action",
"execution",
"exception",
"{",
"write",
"output",
"(",
"read",
"input",
"(",
")",
",",
"\"",
"gen",
"2",
"\"",
")",
";",
"return",
"action",
"result",
"empty",
";",
"}",
"}",
")",
";",
"builder",
"build",
"artifacts",
"(",
"reporter",
",",
"immutable",
"set",
"of",
"(",
"gen",
"file",
"2",
")",
",",
"null",
",",
"null",
",",
"null",
",",
"null",
",",
"null",
",",
"executor",
",",
"null",
",",
"null",
",",
"options",
",",
"null",
",",
"null",
",",
"/",
"*",
"trust",
"remote",
"artifacts",
"=",
"*",
"/",
"false",
")",
";",
"}"
]
|
[
"returns",
"pet",
"inventories",
"by",
"status",
"returns",
"a",
"map",
"of",
"status",
"codes",
"to",
"quantities"
]
| [
"public",
"void",
"get",
"inventory",
"test",
"(",
")",
"throws",
"api",
"exception",
"{",
"map",
"<",
"string",
",",
"integer",
">",
"response",
"=",
"api",
"get",
"inventory",
"(",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
]
|
[
"determines",
"and",
"returns",
"a",
"map",
"from",
"attribute",
"name",
"to",
"list",
"of",
"configured",
"fileset",
"entries",
",",
"based",
"on",
"a",
"prerequisite",
"map",
"instance"
]
| [
"private",
"list",
"multimap",
"<",
"string",
",",
"configured",
"fileset",
"entry",
">",
"create",
"fileset",
"entry",
"map",
"(",
"final",
"rule",
"rule",
",",
"immutable",
"map",
"<",
"label",
",",
"config",
"matching",
"provider",
">",
"config",
"conditions",
")",
"{",
"if",
"(",
"!",
"target",
"get",
"target",
"kind",
"(",
")",
"equals",
"(",
"\"",
"fileset",
"rule",
"\"",
")",
")",
"{",
"return",
"immutable",
"sorted",
"key",
"list",
"multimap",
"<",
"string",
",",
"configured",
"fileset",
"entry",
">",
"builder",
"(",
")",
"build",
"(",
")",
";",
"}",
"final",
"immutable",
"sorted",
"key",
"list",
"multimap",
"builder",
"<",
"string",
",",
"configured",
"fileset",
"entry",
">",
"map",
"builder",
"=",
"immutable",
"sorted",
"key",
"list",
"multimap",
"builder",
"(",
")",
";",
"for",
"(",
"attribute",
"attr",
":",
"rule",
"get",
"attributes",
"(",
")",
")",
"{",
"if",
"(",
"attr",
"get",
"type",
"(",
")",
"!",
"=",
"build",
"type",
"fileset",
"entry",
"list",
")",
"{",
"continue",
";",
"}",
"string",
"attribute",
"name",
"=",
"attr",
"get",
"name",
"(",
")",
";",
"map",
"<",
"label",
",",
"configured",
"target",
"and",
"data",
">",
"ct",
"map",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"for",
"(",
"configured",
"target",
"and",
"data",
"prerequisite",
":",
"prerequisite",
"map",
"get",
"(",
"attr",
")",
")",
"{",
"ct",
"map",
"put",
"(",
"alias",
"provider",
"get",
"dependency",
"label",
"(",
"prerequisite",
"get",
"configured",
"target",
"(",
")",
")",
",",
"prerequisite",
")",
";",
"}",
"list",
"<",
"fileset",
"entry",
">",
"entries",
"=",
"configured",
"attribute",
"mapper",
"of",
"(",
"rule",
",",
"config",
"conditions",
")",
"get",
"(",
"attribute",
"name",
",",
"build",
"type",
"fileset",
"entry",
"list",
")",
";",
"for",
"(",
"fileset",
"entry",
"entry",
":",
"entries",
")",
"{",
"if",
"(",
"entry",
"get",
"files",
"(",
")",
"=",
"=",
"null",
")",
"{",
"label",
"label",
"=",
"entry",
"get",
"src",
"label",
"(",
")",
";",
"configured",
"target",
"and",
"data",
"src",
"=",
"ct",
"map",
"get",
"(",
"label",
")",
";",
"if",
"(",
"!",
"validate",
"fileset",
"entry",
"(",
"entry",
",",
"src",
")",
")",
"{",
"continue",
";",
"}",
"map",
"builder",
"put",
"(",
"attribute",
"name",
",",
"new",
"configured",
"fileset",
"entry",
"(",
"entry",
",",
"src",
"get",
"configured",
"target",
"(",
")",
")",
")",
";",
"}",
"else",
"{",
"immutable",
"list",
"builder",
"<",
"transitive",
"info",
"collection",
">",
"files",
"=",
"immutable",
"list",
"builder",
"(",
")",
";",
"for",
"(",
"label",
"file",
":",
"entry",
"get",
"files",
"(",
")",
")",
"{",
"files",
"add",
"(",
"ct",
"map",
"get",
"(",
"file",
")",
"get",
"configured",
"target",
"(",
")",
")",
";",
"}",
"map",
"builder",
"put",
"(",
"attribute",
"name",
",",
"new",
"configured",
"fileset",
"entry",
"(",
"entry",
",",
"files",
"build",
"(",
")",
")",
")",
";",
"}",
"}",
"}",
"return",
"map",
"builder",
"build",
"(",
")",
";",
"}"
]
|
[
"not",
"supported",
"<",
"b",
">",
"you",
"are",
"attempting",
"to",
"create",
"a",
"map",
"that",
"may",
"contain",
"non",
"-",
"{",
"@",
"code",
"comparable",
"}",
"keys",
"<",
"b",
">",
"proper",
"calls",
"will",
"resolve",
"to",
"the",
"version",
"in",
"{",
"@",
"code",
"immutable",
"sorted",
"map",
"}",
",",
"not",
"this",
"dummy",
"version"
]
| [
"public",
"static",
"<",
"k",
",",
"v",
">",
"immutable",
"sorted",
"map",
"<",
"k",
",",
"v",
">",
"of",
"(",
"k",
"k",
"1",
",",
"v",
"v",
"1",
",",
"k",
"k",
"2",
",",
"v",
"v",
"2",
",",
"k",
"k",
"3",
",",
"v",
"v",
"3",
",",
"k",
"k",
"4",
",",
"v",
"v",
"4",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
")",
";",
"}"
]
|
[
"test",
"a",
"command",
"execution",
"that",
"fails",
"synchronously",
",",
"has",
"get",
"fallback",
"implemented",
"but",
"that",
"fails",
"as",
"well",
"(",
"asynchronously",
")"
]
| [
"public",
"void",
"test",
"semaphore",
"isolated",
"observe",
"sync",
"failure",
"with",
"async",
"fallback",
"failure",
"(",
")",
"{",
"test",
"observe",
"failure",
"with",
"fallback",
"failure",
"(",
"execution",
"isolation",
"strategy",
"semaphore",
",",
"false",
",",
"true",
")",
";",
"}"
]
|
[
"{",
"@",
"inherit",
"doc",
"}",
"<",
"p",
">",
"width",
"is",
"defined",
"by",
"target",
"{",
"@",
"link",
"android",
"view",
"view",
"view",
"}",
"parameters",
",",
"configuration",
"parameters",
"or",
"device",
"display",
"dimensions",
"<",
"br",
">",
"size",
"computing",
"algorithm",
"(",
"go",
"by",
"steps",
"until",
"get",
"non",
"-",
"zero",
"value",
")",
":",
"<",
"br",
">",
"1",
")",
"get",
"the",
"actual",
"drawn",
"<",
"b",
">",
"get",
"width",
"(",
")",
"<",
"b",
">",
"of",
"the",
"view",
"<",
"br",
">",
"2",
")",
"get",
"<",
"b",
">",
"layout",
"width",
"<",
"b",
">"
]
| [
"public",
"int",
"get",
"width",
"(",
")",
"{",
"view",
"view",
"=",
"view",
"ref",
"get",
"(",
")",
";",
"if",
"(",
"view",
"!",
"=",
"null",
")",
"{",
"final",
"view",
"group",
"layout",
"params",
"params",
"=",
"view",
"get",
"layout",
"params",
"(",
")",
";",
"int",
"width",
"=",
"0",
";",
"if",
"(",
"check",
"actual",
"view",
"size",
"&",
"&",
"params",
"!",
"=",
"null",
"&",
"&",
"params",
"width",
"!",
"=",
"view",
"group",
"layout",
"params",
"wrap",
"content",
")",
"{",
"width",
"=",
"view",
"get",
"width",
"(",
")",
";",
"/",
"/",
"get",
"actual",
"image",
"width",
"}",
"if",
"(",
"width",
"<",
"=",
"0",
"&",
"&",
"params",
"!",
"=",
"null",
")",
"width",
"=",
"params",
"width",
";",
"/",
"/",
"get",
"layout",
"width",
"parameter",
"return",
"width",
";",
"}",
"return",
"0",
";",
"}"
]
|
[
"load",
"registered",
"service",
"from",
"the",
"given",
"file"
]
| [
"collection",
"<",
"registered",
"service",
">",
"load",
"(",
"file",
"file",
")",
";"
]
|
[
"return",
"the",
"fill",
"along",
"the",
"main",
"axis",
"(",
"i",
"e",
"height",
"for",
"vertical",
"and",
"width",
"for",
"horizontal",
")",
",",
"this",
"method",
"is",
"available",
"after",
"{",
"@",
"link",
"viewport",
"filler",
"#",
"add",
"(",
"render",
"info",
",",
"int",
",",
"int",
")",
"}",
"is",
"called"
]
| [
"int",
"get",
"fill",
"(",
")",
";"
]
|
[
"saves",
"inode",
"and",
"increments",
"progress",
"counter"
]
| [
"private",
"void",
"save",
"i",
"node",
"2",
"image",
"(",
"i",
"node",
"inode",
",",
"data",
"output",
"stream",
"out",
",",
"boolean",
"write",
"under",
"construction",
",",
"reference",
"map",
"reference",
"map",
",",
"counter",
"counter",
")",
"throws",
"i",
"o",
"exception",
"{",
"f",
"s",
"image",
"serialization",
"save",
"i",
"node",
"2",
"image",
"(",
"inode",
",",
"out",
",",
"write",
"under",
"construction",
",",
"reference",
"map",
")",
";",
"/",
"/",
"intentionally",
"do",
"not",
"increment",
"counter",
"for",
"reference",
"inodes",
",",
"because",
"it",
"/",
"/",
"is",
"too",
"difficult",
"at",
"this",
"point",
"to",
"assess",
"whether",
"or",
"not",
"this",
"is",
"a",
"/",
"/",
"reference",
"that",
"counts",
"toward",
"quota",
"if",
"(",
"!",
"(",
"inode",
"instanceof",
"i",
"node",
"reference",
")",
")",
"{",
"counter",
"increment",
"(",
")",
";",
"}",
"}"
]
|
[
"set",
"the",
"domain",
"description"
]
| [
"public",
"void",
"set",
"description",
"(",
"string",
"description",
")",
"{",
"this",
"description",
"=",
"description",
";",
"}"
]
|
[
"returns",
"a",
"copy",
"of",
"this",
"instance",
"with",
"filtered",
"resources",
"the",
"original",
"object",
"is",
"unchanged"
]
| [
"public",
"resource",
"dependencies",
"filter",
"(",
"rule",
"error",
"consumer",
"error",
"consumer",
",",
"resource",
"filter",
"resource",
"filter",
")",
"throws",
"rule",
"error",
"exception",
"{",
"optional",
"<",
"nested",
"set",
"<",
"artifact",
">",
">",
"filtered",
"resources",
"=",
"resource",
"filter",
"maybe",
"filter",
"dependencies",
"(",
"transitive",
"resources",
")",
";",
"if",
"(",
"!",
"filtered",
"resources",
"is",
"present",
"(",
")",
")",
"{",
"/",
"/",
"no",
"filtering",
"was",
"done",
"return",
"this",
";",
"}",
"/",
"/",
"note",
"that",
"this",
"doesn",
"'",
"t",
"filter",
"any",
"of",
"the",
"dependent",
"artifacts",
"this",
"/",
"/",
"means",
"that",
"if",
"any",
"resource",
"changes",
",",
"the",
"corresponding",
"actions",
"will",
"get",
"/",
"/",
"re",
"-",
"executed",
"return",
"with",
"resources",
"(",
"resource",
"filter",
"filter",
"dependency",
"containers",
"(",
"error",
"consumer",
",",
"transitive",
"resource",
"containers",
")",
",",
"resource",
"filter",
"filter",
"dependency",
"containers",
"(",
"error",
"consumer",
",",
"direct",
"resource",
"containers",
")",
",",
"filtered",
"resources",
"get",
"(",
")",
")",
";",
"}"
]
|
[
"re",
"-",
"initialize",
"the",
"memory",
"cache"
]
| [
"void",
"reinitialize",
"(",
"boolean",
"clear",
"all",
")",
"{",
"if",
"(",
"clear",
"all",
")",
"{",
"ram",
"manager",
"reinitialize",
"(",
")",
";",
"}",
"int",
"allocated",
"size",
"=",
"create",
"new",
"memory",
"block",
"(",
"default",
"block",
"size",
",",
"default",
"block",
"size",
")",
";",
"assert",
"(",
"allocated",
"size",
"=",
"=",
"default",
"block",
"size",
"|",
"|",
"allocated",
"size",
"=",
"=",
"0",
")",
";",
"log",
"debug",
"(",
"\"",
"created",
"a",
"new",
"mem",
"block",
"of",
"\"",
"+",
"allocated",
"size",
")",
";",
"}"
]
|
[
"verifies",
"bug",
"fix",
"for",
"<",
"a",
"href",
"=",
"\"",
"https",
":",
"jira",
"spring",
"iobrowse",
"s",
"p",
"r",
"-",
"11626",
"\"",
">",
"spr",
"-",
"11626"
]
| [
"void",
"ensure",
"mocks",
"are",
"reinjected",
"between",
"tests",
"2",
"(",
")",
"{",
"assert",
"injected",
"servlet",
"request",
"equals",
"request",
"in",
"request",
"context",
"holder",
"(",
")",
";",
"}"
]
|
[
"put",
"j",
"s",
"o",
"n",
"array",
"in",
"cache"
]
| [
"public",
"void",
"put",
"(",
"@",
"non",
"null",
"final",
"string",
"key",
",",
"final",
"j",
"s",
"o",
"n",
"array",
"value",
",",
"final",
"int",
"save",
"time",
")",
"{",
"m",
"cache",
"memory",
"utils",
"put",
"(",
"key",
",",
"value",
",",
"save",
"time",
")",
";",
"m",
"cache",
"disk",
"utils",
"put",
"(",
"key",
",",
"value",
",",
"save",
"time",
")",
";",
"}"
]
|
[
"tells",
"whether",
"all",
"the",
"features",
"provided",
"as",
"argument",
"are",
"supported"
]
| [
"public",
"static",
"boolean",
"are",
"all",
"supported",
"(",
"list",
"<",
"string",
">",
"features",
")",
"{",
"for",
"(",
"string",
"feature",
":",
"features",
")",
"{",
"if",
"(",
"feature",
"equals",
"(",
"\"",
"xpack",
"\"",
")",
")",
"{",
"if",
"(",
"false",
"=",
"=",
"e",
"s",
"rest",
"test",
"case",
"has",
"x",
"pack",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"}",
"else",
"if",
"(",
"feature",
"equals",
"(",
"\"",
"no",
"xpack",
"\"",
")",
")",
"{",
"if",
"(",
"e",
"s",
"rest",
"test",
"case",
"has",
"x",
"pack",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"}",
"else",
"if",
"(",
"false",
"=",
"=",
"supported",
"contains",
"(",
"feature",
")",
")",
"{",
"return",
"false",
";",
"}",
"}",
"return",
"true",
";",
"}"
]
|
[
"override",
"the",
"default",
"{",
"@",
"link",
"locale",
"}",
"to",
"use",
"for",
"formatting",
"default",
"value",
"used",
"is",
"{",
"@",
"link",
"locale",
"#",
"get",
"default",
"(",
")",
"}"
]
| [
"public",
"void",
"set",
"locale",
"(",
"locale",
"locale",
")",
"{",
"this",
"builder",
"locale",
"(",
"locale",
")",
";",
"}"
]
|
[
"clears",
"all",
"text",
"from",
"the",
"information",
"buffer"
]
| [
"void",
"clear",
"resolve",
"info",
"(",
")",
"{",
"if",
"(",
"info",
"buf",
"length",
"(",
")",
">",
"0",
")",
"{",
"info",
"buf",
"=",
"new",
"string",
"buffer",
"(",
")",
";",
"}",
"}"
]
|
[
"create",
"user",
"this",
"can",
"only",
"be",
"done",
"by",
"the",
"logged",
"in",
"user"
]
| [
"public",
"void",
"create",
"user",
"(",
"user",
"body",
",",
"handler",
"<",
"async",
"result",
"<",
"void",
">",
">",
"result",
"handler",
")",
"{",
"create",
"user",
"(",
"body",
",",
"null",
",",
"result",
"handler",
")",
";",
"}"
]
|
[
"explicitly",
"specifies",
"the",
"return",
"type",
"of",
"this",
"{",
"@",
"code",
"invokable",
"}",
"for",
"example",
":",
"{",
"@",
"code",
"method",
"factory",
"method",
"=",
"person",
"class",
"get",
"method",
"(",
"\"",
"create",
"\"",
")",
";",
"invokable",
"<",
"?",
",",
"person",
">",
"factory",
"=",
"invokable",
"of",
"(",
"get",
"name",
"method",
")",
"returning",
"(",
"person",
"class",
")",
";",
"}"
]
| [
"public",
"final",
"<",
"r1",
"extends",
"r",
">",
"invokable",
"<",
"t",
",",
"r1",
">",
"returning",
"(",
"class",
"<",
"r1",
">",
"return",
"type",
")",
"{",
"return",
"returning",
"(",
"type",
"token",
"of",
"(",
"return",
"type",
")",
")",
";",
"}"
]
|
[
"refresh",
"is",
"called",
"to",
"execute",
"new",
"querybrowse",
"new",
"data",
"it",
"is",
"public",
"api",
"function"
]
| [
"public",
"void",
"refresh",
"(",
")",
"{",
"if",
"(",
"!",
"check",
"for",
"changes",
"(",
")",
")",
"{",
"return",
";",
"}",
"/",
"/",
"disable",
"auto",
"-",
"refresh",
"auto",
"refresh",
"control",
"enable",
"auto",
"refresh",
"(",
"false",
")",
";",
"/",
"/",
"pump",
"data",
"d",
"b",
"s",
"data",
"container",
"data",
"container",
"=",
"get",
"data",
"container",
"(",
")",
";",
"if",
"(",
"data",
"container",
"!",
"=",
"null",
")",
"{",
"d",
"b",
"d",
"data",
"filter",
"data",
"filter",
"=",
"restore",
"data",
"filter",
"(",
"data",
"container",
")",
";",
"int",
"segment",
"size",
"=",
"get",
"segment",
"max",
"rows",
"(",
")",
";",
"runnable",
"finalizer",
"=",
"(",
")",
"-",
">",
"{",
"if",
"(",
"active",
"presentation",
"get",
"control",
"(",
")",
"!",
"=",
"null",
"&",
"&",
"!",
"active",
"presentation",
"get",
"control",
"(",
")",
"is",
"disposed",
"(",
")",
")",
"{",
"active",
"presentation",
"format",
"data",
"(",
"true",
")",
";",
"}",
"}",
";",
"data",
"receiver",
"set",
"next",
"segment",
"read",
"(",
"false",
")",
";",
"/",
"/",
"trick",
"-",
"in",
"fact",
"it",
"is",
"not",
"a",
"refresh",
"but",
"\"",
"execute",
"\"",
"action",
"run",
"data",
"pump",
"(",
"data",
"container",
",",
"data",
"filter",
",",
"0",
",",
"segment",
"size",
",",
"0",
",",
"true",
",",
"false",
",",
"false",
",",
"finalizer",
")",
";",
"}",
"else",
"{",
"d",
"b",
"workbench",
"get",
"platform",
"u",
"i",
"(",
")",
"show",
"error",
"(",
"\"",
"error",
"executing",
"query",
"\"",
",",
"\"",
"viewer",
"detached",
"from",
"data",
"source",
"\"",
")",
";",
"}",
"}"
]
|
[
"the",
"indices",
"into",
"which",
"the",
"mappings",
"will",
"be",
"put"
]
| [
"public",
"string",
"[",
"]",
"indices",
"(",
")",
"{",
"return",
"indices",
";",
"}"
]
|
[
"required",
":",
"one",
"or",
"more",
"labels",
"that",
"indicate",
"a",
"specific",
"set",
"of",
"pods",
"v",
"ms",
"on",
"which",
"this",
"gateway",
"configuration",
"should",
"be",
"applied",
"the",
"scope",
"of",
"label",
"search",
"is",
"restricted",
"to",
"the",
"configuration",
"namespace",
"in",
"which",
"the",
"the",
"resource",
"is",
"present",
"in",
"other",
"words",
",",
"the",
"gateway",
"resource",
"must",
"reside",
"in",
"the",
"same",
"namespace",
"as",
"the",
"gateway",
"workload",
"instance",
"<",
"code",
">",
"map",
"&",
"lt",
";",
"string",
",",
"string",
"&",
"gt",
";",
"selector",
"=",
"2",
";",
"<",
"code",
">"
]
| [
"public",
"builder",
"remove",
"selector",
"(",
"java",
"lang",
"string",
"key",
")",
"{",
"if",
"(",
"key",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"java",
"lang",
"null",
"pointer",
"exception",
"(",
")",
";",
"}",
"internal",
"get",
"mutable",
"selector",
"(",
")",
"get",
"mutable",
"map",
"(",
")",
"remove",
"(",
"key",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"to",
"match",
"finagle"
]
| [
"public",
"void",
"writes",
"debug",
"false",
"(",
")",
"{",
"span",
"=",
"span",
"to",
"builder",
"(",
")",
"debug",
"(",
"false",
")",
"build",
"(",
")",
";",
"writer",
"write",
"(",
"span",
",",
"buf",
")",
";",
"assert",
"that",
"(",
"bytes",
")",
"contains",
"sequence",
"(",
"thrift",
"field",
"type",
"bool",
",",
"0",
")",
";",
"}"
]
|
[
"gets",
"the",
"grouped",
"fields"
]
| [
"public",
"field",
"set",
"get",
"grouped",
"fields",
"(",
")",
"{",
"return",
"this",
"grouped",
"fields",
";",
"}"
]
|
[
"puts",
"a",
"keyvalue",
"pair",
"into",
"the",
"array",
",",
"optimizing",
"for",
"the",
"case",
"where",
"the",
"key",
"is",
"greater",
"than",
"all",
"existing",
"keys",
"in",
"the",
"array"
]
| [
"public",
"void",
"append",
"(",
"long",
"key",
",",
"e",
"value",
")",
"{",
"if",
"(",
"m",
"size",
"!",
"=",
"0",
"&",
"&",
"key",
"<",
"=",
"m",
"keys",
"[",
"m",
"size",
"-",
"1",
"]",
")",
"{",
"put",
"(",
"key",
",",
"value",
")",
";",
"return",
";",
"}",
"if",
"(",
"m",
"garbage",
"&",
"&",
"m",
"size",
">",
"=",
"m",
"keys",
"length",
")",
"{",
"gc",
"(",
")",
";",
"}",
"int",
"pos",
"=",
"m",
"size",
";",
"if",
"(",
"pos",
">",
"=",
"m",
"keys",
"length",
")",
"{",
"int",
"n",
"=",
"array",
"utils",
"ideal",
"int",
"array",
"size",
"(",
"pos",
"+",
"1",
")",
";",
"long",
"[",
"]",
"nkeys",
"=",
"new",
"long",
"[",
"n",
"]",
";",
"object",
"[",
"]",
"nvalues",
"=",
"new",
"object",
"[",
"n",
"]",
";",
"/",
"/",
"log",
"e",
"(",
"\"",
"sparse",
"array",
"\"",
",",
"\"",
"grow",
"\"",
"+",
"m",
"keys",
"length",
"+",
"\"",
"to",
"\"",
"+",
"n",
")",
";",
"system",
"arraycopy",
"(",
"m",
"keys",
",",
"0",
",",
"nkeys",
",",
"0",
",",
"m",
"keys",
"length",
")",
";",
"system",
"arraycopy",
"(",
"m",
"values",
",",
"0",
",",
"nvalues",
",",
"0",
",",
"m",
"values",
"length",
")",
";",
"m",
"keys",
"=",
"nkeys",
";",
"m",
"values",
"=",
"nvalues",
";",
"}",
"m",
"keys",
"[",
"pos",
"]",
"=",
"key",
";",
"m",
"values",
"[",
"pos",
"]",
"=",
"value",
";",
"m",
"size",
"=",
"pos",
"+",
"1",
";",
"}"
]
|
[
"create",
"an",
"f",
"s",
"data",
"output",
"stream",
"at",
"the",
"indicated",
"path",
"with",
"write",
"-",
"progress",
"reporting",
"files",
"are",
"overwritten",
"by",
"default"
]
| [
"public",
"f",
"s",
"data",
"output",
"stream",
"create",
"(",
"path",
"f",
",",
"short",
"replication",
",",
"progressable",
"progress",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"create",
"(",
"f",
",",
"true",
",",
"get",
"conf",
"(",
")",
"get",
"int",
"(",
"io",
"file",
"buffer",
"size",
"key",
",",
"io",
"file",
"buffer",
"size",
"default",
")",
",",
"replication",
",",
"get",
"default",
"block",
"size",
"(",
"f",
")",
",",
"progress",
")",
";",
"}"
]
|
[
"calculate",
"the",
"limit",
"for",
"a",
"get",
"request",
",",
"based",
"on",
"input",
"policy",
"and",
"state",
"of",
"object"
]
| [
"static",
"long",
"calculate",
"request",
"limit",
"(",
"s",
"3",
"a",
"input",
"policy",
"input",
"policy",
",",
"long",
"target",
"pos",
",",
"long",
"length",
",",
"long",
"content",
"length",
",",
"long",
"readahead",
")",
"{",
"long",
"range",
"limit",
";",
"switch",
"(",
"input",
"policy",
")",
"{",
"case",
"random",
":",
"/",
"/",
"positioned",
"/",
"/",
"read",
"either",
"this",
"block",
",",
"or",
"the",
"here",
"+",
"readahead",
"value",
"range",
"limit",
"=",
"(",
"length",
"<",
"0",
")",
"?",
"content",
"length",
":",
"target",
"pos",
"+",
"math",
"max",
"(",
"readahead",
",",
"length",
")",
";",
"break",
";",
"case",
"sequential",
":",
"/",
"/",
"sequential",
":",
"plan",
"for",
"reading",
"the",
"entire",
"object",
"range",
"limit",
"=",
"content",
"length",
";",
"break",
";",
"case",
"normal",
":",
"/",
"/",
"normal",
"is",
"considered",
"sequential",
"until",
"a",
"backwards",
"seek",
"switches",
"/",
"/",
"it",
"to",
"'",
"random",
"'",
"default",
":",
"range",
"limit",
"=",
"content",
"length",
";",
"}",
"/",
"/",
"cannot",
"read",
"past",
"the",
"end",
"of",
"the",
"object",
"range",
"limit",
"=",
"math",
"min",
"(",
"content",
"length",
",",
"range",
"limit",
")",
";",
"return",
"range",
"limit",
";",
"}"
]
|
[
"{",
"@",
"inherit",
"doc",
"}",
"this",
"method",
"calls",
"{",
"@",
"code",
"replace",
"(",
"content",
"(",
")",
"duplicate",
"(",
")",
")",
"}",
"by",
"default"
]
| [
"public",
"byte",
"buf",
"holder",
"duplicate",
"(",
")",
"{",
"return",
"replace",
"(",
"data",
"duplicate",
"(",
")",
")",
";",
"}"
]
|
[
"returns",
"pet",
"inventories",
"by",
"status",
"returns",
"a",
"map",
"of",
"status",
"codes",
"to",
"quantities"
]
| [
"public",
"void",
"get",
"inventory",
"test",
"(",
")",
"throws",
"api",
"exception",
"{",
"completable",
"future",
"<",
"map",
"<",
"string",
",",
"integer",
">",
">",
"response",
"=",
"api",
"get",
"inventory",
"(",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
]
|
[
"returns",
"an",
"array",
"of",
"{",
"@",
"link",
"annotation",
"}",
"objects",
"reflecting",
"all",
"annotations",
"declared",
"by",
"this",
"method",
",",
"or",
"an",
"empty",
"array",
"if",
"there",
"are",
"none",
"does",
"not",
"include",
"inherited",
"annotations",
"does",
"not",
"include",
"parameter",
"annotations"
]
| [
"public",
"annotation",
"[",
"]",
"get",
"declared",
"annotations",
"(",
")",
"{",
"java",
"lang",
"annotation",
"annotation",
"[",
"]",
"annotations",
"=",
"method",
"get",
"declared",
"annotations",
"(",
")",
";",
"annotation",
"[",
"]",
"result",
"=",
"new",
"annotation",
"[",
"annotations",
"length",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"annotations",
"length",
";",
"i",
"+",
"+",
")",
"{",
"result",
"[",
"i",
"]",
"=",
"new",
"annotation",
"(",
"annotations",
"[",
"i",
"]",
")",
";",
"}",
"return",
"result",
";",
"}"
]
|
[
"<",
"code",
">",
"optional",
"second",
"msg",
"blah",
"=",
"2",
";",
"<",
"code",
">"
]
| [
"public",
"org",
"springframework",
"protobuf",
"second",
"msg",
"get",
"blah",
"(",
")",
"{",
"return",
"blah",
";",
"}"
]
|
[
"applies",
"this",
"function",
"to",
"the",
"given",
"argument",
"and",
"its",
"index",
"within",
"a",
"stream"
]
| [
"r",
"apply",
"(",
"double",
"from",
",",
"long",
"index",
")",
";"
]
|
[
"create",
"(",
"or",
"find",
"if",
"already",
"exists",
")",
"an",
"edit",
"output",
"stream",
",",
"which",
"streams",
"journal",
"records",
"(",
"edits",
")",
"to",
"the",
"specified",
"backup",
"node",
"<",
"br",
">",
"the",
"new",
"backup",
"node",
"will",
"start",
"receiving",
"edits",
"the",
"next",
"time",
"this",
"name",
"node",
"'",
"s",
"logs",
"roll"
]
| [
"synchronized",
"void",
"register",
"backup",
"node",
"(",
"namenode",
"registration",
"bn",
"reg",
",",
"/",
"/",
"backup",
"node",
"namenode",
"registration",
"nn",
"reg",
")",
"/",
"/",
"active",
"name",
"-",
"node",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"bn",
"reg",
"is",
"role",
"(",
"namenode",
"role",
"checkpoint",
")",
")",
"return",
";",
"/",
"/",
"checkpoint",
"node",
"does",
"not",
"stream",
"edits",
"journal",
"manager",
"jas",
"=",
"find",
"backup",
"journal",
"(",
"bn",
"reg",
")",
";",
"if",
"(",
"jas",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"already",
"registered",
"log",
"info",
"(",
"\"",
"backup",
"node",
"\"",
"+",
"bn",
"reg",
"+",
"\"",
"re",
"-",
"registers",
"\"",
")",
";",
"return",
";",
"}",
"log",
"info",
"(",
"\"",
"registering",
"new",
"backup",
"node",
":",
"\"",
"+",
"bn",
"reg",
")",
";",
"backup",
"journal",
"manager",
"bjm",
"=",
"new",
"backup",
"journal",
"manager",
"(",
"bn",
"reg",
",",
"nn",
"reg",
")",
";",
"synchronized",
"(",
"journal",
"set",
"lock",
")",
"{",
"journal",
"set",
"add",
"(",
"bjm",
",",
"false",
")",
";",
"}",
"}"
]
|
[
"surrounds",
"the",
"indicated",
"text",
"with",
"html",
"font",
"coloring",
"tags",
"so",
"that",
"the",
"text",
"will",
"display",
"in",
"color",
"within",
"html",
"the",
"given",
"color",
"will",
"be",
"converted",
"to",
"its",
"hex",
"value"
]
| [
"public",
"static",
"string",
"color",
"string",
"(",
"color",
"color",
",",
"string",
"text",
")",
"{",
"string",
"rgb",
"=",
"to",
"hex",
"string",
"(",
"color",
")",
";",
"return",
"\"",
"<",
"font",
"color",
"=",
"\\",
"\"",
"\"",
"+",
"rgb",
"+",
"\"",
"\\",
"\"",
">",
"\"",
"+",
"text",
"+",
"\"",
"<",
"/",
"font",
">",
"\"",
";",
"}"
]
|
[
"returns",
"the",
"associated",
"key",
"type"
]
| [
"public",
"class",
"<",
"k",
">",
"key",
"type",
"(",
")",
"{",
"return",
"key",
"type",
";",
"}"
]
|
[
"should",
"rendering",
"of",
"this",
"tag",
"proceed",
"at",
"all",
"?",
"only",
"renders",
"output",
"when",
"there",
"are",
"errors",
"for",
"the",
"configured",
"{",
"@",
"link",
"#",
"set",
"path",
"path",
"}"
]
| [
"protected",
"boolean",
"should",
"render",
"(",
")",
"throws",
"jsp",
"exception",
"{",
"try",
"{",
"return",
"get",
"bind",
"status",
"(",
")",
"is",
"error",
"(",
")",
";",
"}",
"catch",
"(",
"illegal",
"state",
"exception",
"ex",
")",
"{",
"/",
"/",
"neither",
"binding",
"result",
"nor",
"target",
"object",
"available",
"return",
"false",
";",
"}",
"}"
]
|
[
"to",
"test",
"special",
"tags",
"to",
"test",
"special",
"tags",
"and",
"operation",
"id",
"starting",
"with",
"number"
]
| [
"public",
"void",
"call",
"1",
"2",
"3test",
"special",
"tags",
"test",
"(",
")",
"{",
"client",
"client",
"=",
"null",
";",
"/",
"/",
"client",
"response",
"=",
"api",
"call",
"1",
"2",
"3test",
"special",
"tags",
"(",
"client",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
]
|
[
"gets",
"the",
"custom",
"partitioner",
"used",
"by",
"this",
"join",
",",
"or",
"{",
"@",
"code",
"null",
"}",
",",
"if",
"none",
"is",
"set"
]
| [
"public",
"partitioner",
"<",
"?",
">",
"get",
"partitioner",
"(",
")",
"{",
"return",
"custom",
"partitioner",
";",
"}"
]
|
[
"returns",
"the",
"working",
"directory",
"of",
"the",
"{",
"@",
"code",
"blaze",
"}",
"client",
"process",
"this",
"may",
"be",
"equal",
"to",
"{",
"@",
"code",
"blaze",
"runtime",
"#",
"get",
"workspace",
"(",
")",
"}",
",",
"or",
"beneath",
"it"
]
| [
"public",
"path",
"get",
"working",
"directory",
"(",
")",
"{",
"return",
"working",
"directory",
";",
"}"
]
|
[
"makes",
"time",
"pass",
"for",
"weather"
]
| [
"public",
"void",
"time",
"passes",
"(",
")",
"{",
"var",
"enum",
"values",
"=",
"weather",
"type",
"values",
"(",
")",
";",
"current",
"weather",
"=",
"enum",
"values",
"[",
"(",
"current",
"weather",
"ordinal",
"(",
")",
"+",
"1",
")",
"%",
"enum",
"values",
"length",
"]",
";",
"logger",
"info",
"(",
"\"",
"the",
"weather",
"changed",
"to",
"{",
"}",
"\"",
",",
"current",
"weather",
")",
";",
"notify",
"observers",
"(",
")",
";",
"}"
]
|
[
"test",
"get",
"blocks"
]
| [
"public",
"void",
"test",
"get",
"blocks",
"(",
")",
"throws",
"exception",
"{",
"distributed",
"file",
"system",
"fs",
"=",
"null",
";",
"path",
"test",
"file",
"=",
"null",
";",
"block",
"with",
"locations",
"[",
"]",
"locs",
";",
"final",
"int",
"blk",
"size",
"=",
"1024",
";",
"final",
"string",
"file",
"path",
"=",
"\"",
"/",
"tmp",
"txt",
"\"",
";",
"final",
"int",
"blk",
"locs",
"size",
"=",
"13",
";",
"long",
"file",
"len",
"=",
"12",
"*",
"blk",
"size",
"+",
"1",
";",
"final",
"short",
"replication",
"factor",
"=",
"(",
"short",
")",
"2",
";",
"final",
"configuration",
"config",
"=",
"new",
"hdfs",
"configuration",
"(",
")",
";",
"/",
"/",
"set",
"configurations",
"config",
"set",
"long",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"block",
"size",
"key",
",",
"blk",
"size",
")",
";",
"config",
"set",
"long",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"balancer",
"getblocks",
"min",
"block",
"size",
"key",
",",
"blk",
"size",
")",
";",
"mini",
"d",
"f",
"s",
"cluster",
"cluster",
"=",
"new",
"mini",
"d",
"f",
"s",
"cluster",
"builder",
"(",
"config",
")",
"num",
"data",
"nodes",
"(",
"replication",
"factor",
")",
"storages",
"per",
"datanode",
"(",
"4",
")",
"build",
"(",
")",
";",
"try",
"{",
"cluster",
"wait",
"active",
"(",
")",
";",
"/",
"/",
"the",
"third",
"block",
"will",
"not",
"be",
"visible",
"to",
"get",
"blocks",
"test",
"file",
"=",
"new",
"path",
"(",
"file",
"path",
")",
";",
"d",
"f",
"s",
"test",
"util",
"create",
"file",
"(",
"cluster",
"get",
"file",
"system",
"(",
")",
",",
"test",
"file",
",",
"file",
"len",
",",
"replication",
"factor",
",",
"0l",
")",
";",
"/",
"/",
"get",
"blocks",
"&",
"data",
"nodes",
"fs",
"=",
"cluster",
"get",
"file",
"system",
"(",
")",
";",
"d",
"f",
"s",
"test",
"util",
"wait",
"for",
"replication",
"(",
"fs",
",",
"test",
"file",
",",
"replication",
"factor",
",",
"60000",
")",
";",
"remote",
"iterator",
"<",
"located",
"file",
"status",
">",
"it",
"=",
"fs",
"list",
"located",
"status",
"(",
"test",
"file",
")",
";",
"located",
"file",
"status",
"stat",
"=",
"it",
"next",
"(",
")",
";",
"block",
"location",
"[",
"]",
"block",
"locations",
"=",
"stat",
"get",
"block",
"locations",
"(",
")",
";",
"assert",
"equals",
"(",
"blk",
"locs",
"size",
",",
"block",
"locations",
"length",
")",
";",
"hdfs",
"data",
"input",
"stream",
"dis",
"=",
"(",
"hdfs",
"data",
"input",
"stream",
")",
"fs",
"open",
"(",
"test",
"file",
")",
";",
"collection",
"<",
"located",
"block",
">",
"dinfo",
"=",
"dis",
"get",
"all",
"blocks",
"(",
")",
";",
"dis",
"close",
"(",
")",
";",
"datanode",
"info",
"[",
"]",
"data",
"nodes",
"=",
"dinfo",
"iterator",
"(",
")",
"next",
"(",
")",
"get",
"locations",
"(",
")",
";",
"/",
"/",
"get",
"rpc",
"client",
"to",
"namenode",
"inet",
"socket",
"address",
"addr",
"=",
"new",
"inet",
"socket",
"address",
"(",
"\"",
"localhost",
"\"",
",",
"cluster",
"get",
"name",
"node",
"port",
"(",
")",
")",
";",
"namenode",
"protocol",
"namenode",
"=",
"name",
"node",
"proxies",
"create",
"proxy",
"(",
"config",
",",
"d",
"f",
"s",
"util",
"client",
"get",
"n",
"n",
"uri",
"(",
"addr",
")",
",",
"namenode",
"protocol",
"class",
")",
"get",
"proxy",
"(",
")",
";",
"/",
"/",
"should",
"return",
"all",
"13",
"blocks",
",",
"as",
"min",
"block",
"size",
"is",
"not",
"passed",
"locs",
"=",
"namenode",
"get",
"blocks",
"(",
"data",
"nodes",
"[",
"0",
"]",
",",
"file",
"len",
",",
"0",
",",
"0",
")",
"get",
"blocks",
"(",
")",
";",
"assert",
"equals",
"(",
"blk",
"locs",
"size",
",",
"locs",
"length",
")",
";",
"assert",
"equals",
"(",
"locs",
"[",
"0",
"]",
"get",
"storage",
"i",
"ds",
"(",
")",
"length",
",",
"replication",
"factor",
")",
";",
"assert",
"equals",
"(",
"locs",
"[",
"1",
"]",
"get",
"storage",
"i",
"ds",
"(",
")",
"length",
",",
"replication",
"factor",
")",
";",
"/",
"/",
"should",
"return",
"12",
"blocks",
",",
"as",
"min",
"block",
"size",
"is",
"blk",
"size",
"locs",
"=",
"namenode",
"get",
"blocks",
"(",
"data",
"nodes",
"[",
"0",
"]",
",",
"file",
"len",
",",
"blk",
"size",
",",
"0",
")",
"get",
"blocks",
"(",
")",
";",
"assert",
"equals",
"(",
"blk",
"locs",
"size",
"-",
"1",
",",
"locs",
"length",
")",
";",
"assert",
"equals",
"(",
"locs",
"[",
"0",
"]",
"get",
"storage",
"i",
"ds",
"(",
")",
"length",
",",
"replication",
"factor",
")",
";",
"assert",
"equals",
"(",
"locs",
"[",
"1",
"]",
"get",
"storage",
"i",
"ds",
"(",
")",
"length",
",",
"replication",
"factor",
")",
";",
"/",
"/",
"get",
"blocks",
"of",
"size",
"block",
"size",
"from",
"data",
"nodes",
"[",
"0",
"]",
"locs",
"=",
"namenode",
"get",
"blocks",
"(",
"data",
"nodes",
"[",
"0",
"]",
",",
"blk",
"size",
",",
"blk",
"size",
",",
"0",
")",
"get",
"blocks",
"(",
")",
";",
"assert",
"equals",
"(",
"locs",
"length",
",",
"1",
")",
";",
"assert",
"equals",
"(",
"locs",
"[",
"0",
"]",
"get",
"storage",
"i",
"ds",
"(",
")",
"length",
",",
"replication",
"factor",
")",
";",
"/",
"/",
"get",
"blocks",
"of",
"size",
"1",
"from",
"data",
"nodes",
"[",
"0",
"]",
"locs",
"=",
"namenode",
"get",
"blocks",
"(",
"data",
"nodes",
"[",
"0",
"]",
",",
"1",
",",
"1",
",",
"0",
")",
"get",
"blocks",
"(",
")",
";",
"assert",
"equals",
"(",
"locs",
"length",
",",
"1",
")",
";",
"assert",
"equals",
"(",
"locs",
"[",
"0",
"]",
"get",
"storage",
"i",
"ds",
"(",
")",
"length",
",",
"replication",
"factor",
")",
";",
"/",
"/",
"get",
"blocks",
"of",
"size",
"0",
"from",
"data",
"nodes",
"[",
"0",
"]",
"get",
"blocks",
"with",
"exception",
"(",
"namenode",
",",
"data",
"nodes",
"[",
"0",
"]",
",",
"0",
",",
"0",
",",
"remote",
"exception",
"class",
",",
"\"",
"illegal",
"argument",
"exception",
"\"",
")",
";",
"/",
"/",
"get",
"blocks",
"of",
"size",
"-",
"1",
"from",
"data",
"nodes",
"[",
"0",
"]",
"get",
"blocks",
"with",
"exception",
"(",
"namenode",
",",
"data",
"nodes",
"[",
"0",
"]",
",",
"-",
"1",
",",
"0",
",",
"remote",
"exception",
"class",
",",
"\"",
"illegal",
"argument",
"exception",
"\"",
")",
";",
"/",
"/",
"min",
"block",
"size",
"is",
"-",
"1",
"get",
"blocks",
"with",
"exception",
"(",
"namenode",
",",
"data",
"nodes",
"[",
"0",
"]",
",",
"blk",
"size",
",",
"-",
"1",
",",
"remote",
"exception",
"class",
",",
"\"",
"illegal",
"argument",
"exception",
"\"",
")",
";",
"/",
"/",
"get",
"blocks",
"of",
"size",
"block",
"size",
"from",
"a",
"non",
"-",
"existent",
"datanode",
"datanode",
"info",
"info",
"=",
"d",
"f",
"s",
"test",
"util",
"get",
"datanode",
"info",
"(",
"\"",
"1",
"2",
"3",
"4",
"\"",
")",
";",
"get",
"blocks",
"with",
"exception",
"(",
"namenode",
",",
"info",
",",
"replication",
"factor",
",",
"0",
",",
"remote",
"exception",
"class",
",",
"\"",
"hadoop",
"illegal",
"argument",
"exception",
"\"",
")",
";",
"test",
"block",
"iterator",
"(",
"cluster",
")",
";",
"/",
"/",
"namenode",
"should",
"refuse",
"to",
"provide",
"block",
"locations",
"to",
"the",
"balancer",
"/",
"/",
"while",
"in",
"safemode",
"locs",
"=",
"namenode",
"get",
"blocks",
"(",
"data",
"nodes",
"[",
"0",
"]",
",",
"file",
"len",
",",
"0",
",",
"0",
")",
"get",
"blocks",
"(",
")",
";",
"assert",
"equals",
"(",
"blk",
"locs",
"size",
",",
"locs",
"length",
")",
";",
"assert",
"false",
"(",
"fs",
"is",
"in",
"safe",
"mode",
"(",
")",
")",
";",
"log",
"info",
"(",
"\"",
"entering",
"safe",
"mode",
"\"",
")",
";",
"fs",
"set",
"safe",
"mode",
"(",
"safe",
"mode",
"action",
"safemode",
"enter",
")",
";",
"log",
"info",
"(",
"\"",
"entered",
"safe",
"mode",
"\"",
")",
";",
"assert",
"true",
"(",
"fs",
"is",
"in",
"safe",
"mode",
"(",
")",
")",
";",
"get",
"blocks",
"with",
"exception",
"(",
"namenode",
",",
"info",
",",
"replication",
"factor",
",",
"0",
",",
"remote",
"exception",
"class",
",",
"\"",
"cannot",
"execute",
"get",
"blocks",
"name",
"node",
"is",
"in",
"safe",
"mode",
"\"",
")",
";",
"fs",
"set",
"safe",
"mode",
"(",
"safe",
"mode",
"action",
"safemode",
"leave",
")",
";",
"assert",
"false",
"(",
"fs",
"is",
"in",
"safe",
"mode",
"(",
")",
")",
";",
"}",
"finally",
"{",
"if",
"(",
"fs",
"!",
"=",
"null",
")",
"{",
"fs",
"delete",
"(",
"test",
"file",
",",
"true",
")",
";",
"fs",
"close",
"(",
")",
";",
"}",
"cluster",
"shutdown",
"(",
")",
";",
"}",
"}"
]
|
[
"used",
"for",
"asynchronous",
"execution",
"of",
"command",
"with",
"a",
"callback",
"by",
"subscribing",
"to",
"the",
"{",
"@",
"link",
"observable",
"}",
"this",
"eagerly",
"starts",
"execution",
"of",
"the",
"command",
"the",
"same",
"as",
"{",
"@",
"link",
"#",
"queue",
"(",
")",
"}",
"and",
"{",
"@",
"link",
"#",
"execute",
"(",
")",
"}",
"a",
"lazy",
"{",
"@",
"link",
"observable",
"}",
"can",
"be",
"obtained",
"from",
"{",
"@",
"link",
"hystrix",
"command",
"#",
"to",
"observable",
"(",
")",
"}",
"or",
"{",
"@",
"link",
"hystrix",
"collapser",
"#",
"to",
"observable",
"(",
")",
"}",
"<",
"b",
">",
"callback",
"scheduling",
"<",
"b",
">",
"when",
"using",
"{",
"@",
"link",
"execution",
"isolation",
"strategy",
"#",
"thread",
"}",
"this",
"defaults",
"to",
"using",
"{",
"@",
"link",
"schedulers",
"#",
"computation",
"(",
")",
"}",
"for",
"callbacks",
"when",
"using",
"{",
"@",
"link",
"execution",
"isolation",
"strategy",
"#",
"semaphore",
"}",
"this",
"defaults",
"to",
"using",
"{",
"@",
"link",
"schedulers",
"#",
"immediate",
"(",
")",
"}",
"for",
"callbacks",
"see",
"https",
":",
"github",
"com",
"netflix",
"rx",
"javawiki",
"for",
"more",
"information"
]
| [
"public",
"observable",
"<",
"r",
">",
"observe",
"(",
")",
";"
]
|
[
"create",
"a",
"key",
"from",
"the",
"table",
"id",
"and",
"the",
"key",
"obtained",
"from",
"the",
"database",
"table",
";",
"the",
"upper",
"8",
"bits",
"indicates",
"which",
"data",
"type",
"table",
"should",
"be",
"accessed"
]
| [
"static",
"long",
"create",
"key",
"(",
"int",
"table",
"i",
"d",
",",
"long",
"table",
"key",
")",
"{",
"long",
"key",
"=",
"(",
"long",
")",
"table",
"i",
"d",
"<",
"<",
"data",
"type",
"kind",
"shift",
";",
"return",
"key",
"|",
"=",
"table",
"key",
";",
"}"
]
|
[
"configure",
"the",
"registry",
"for",
"adapting",
"various",
"reactive",
"types",
"when",
"{",
"@",
"link",
"#",
"set",
"r",
"socket",
"strategies",
"(",
"r",
"socket",
"strategies",
")",
"rsocket",
"strategies",
"}",
"is",
"set",
",",
"this",
"property",
"is",
"re",
"-",
"initialized",
"with",
"the",
"registry",
"in",
"it",
",",
"and",
"likewise",
"when",
"this",
"property",
"is",
"set",
"the",
"{",
"@",
"code",
"r",
"socket",
"strategies",
"}",
"are",
"mutated",
"to",
"change",
"the",
"registry",
"in",
"it",
"by",
"default",
"this",
"is",
"set",
"to",
"the",
"{",
"@",
"link",
"org",
"springframework",
"messaging",
"rsocket",
"r",
"socket",
"strategies",
"builder",
"#",
"reactive",
"adapter",
"strategy",
"(",
"reactive",
"adapter",
"registry",
")",
"defaults",
"}",
"from",
"{",
"@",
"code",
"r",
"socket",
"strategies",
"}"
]
| [
"public",
"void",
"set",
"reactive",
"adapter",
"registry",
"(",
"reactive",
"adapter",
"registry",
"registry",
")",
"{",
"super",
"set",
"reactive",
"adapter",
"registry",
"(",
"registry",
")",
";",
"this",
"strategies",
"=",
"this",
"strategies",
"mutate",
"(",
")",
"reactive",
"adapter",
"strategy",
"(",
"registry",
")",
"build",
"(",
")",
";",
"}"
]
|
[
"asserts",
"that",
"an",
"expansion",
"with",
"a",
"given",
"mapping",
"produces",
"the",
"expected",
"results"
]
| [
"private",
"void",
"assert",
"expansion",
"(",
"string",
"expected",
"result",
",",
"string",
"expression",
"to",
"expand",
",",
"map",
"<",
"label",
",",
"iterable",
"<",
"artifact",
">",
">",
"mapping",
")",
"throws",
"exception",
"{",
"assert",
"that",
"(",
"label",
"expander",
"expand",
"(",
"expression",
"to",
"expand",
",",
"mapping",
",",
"dummy",
"target",
"get",
"label",
"(",
")",
")",
")",
"is",
"equal",
"to",
"(",
"expected",
"result",
")",
";",
"}"
]
|
[
"bean",
"shell",
"scripts",
"do",
"require",
"a",
"config",
"interface"
]
| [
"public",
"boolean",
"requires",
"config",
"interface",
"(",
")",
"{",
"return",
"true",
";",
"}"
]
|
[
"extension",
"point",
"for",
"deployers",
"to",
"define",
"custom",
"audit",
"action",
"resolvers",
"to",
"extend",
"the",
"stock",
"resolvers"
]
| [
"public",
"map",
"<",
"string",
",",
"audit",
"action",
"resolver",
">",
"custom",
"audit",
"action",
"resolver",
"map",
"(",
")",
"{",
"return",
"new",
"hash",
"map",
"<",
">",
"(",
"0",
")",
";",
"}"
]
|
[
"gets",
"the",
"address",
"of",
"the",
"rtti2",
"that",
"is",
"referred",
"to",
"from",
"an",
"rtti3",
"structure",
"that",
"is",
"placed",
"at",
"the",
"indicated",
"address"
]
| [
"public",
"address",
"get",
"rtti",
"2",
"address",
"(",
"memory",
"memory",
",",
"address",
"rtti",
"3",
"address",
")",
"{",
"program",
"program",
"=",
"memory",
"get",
"program",
"(",
")",
";",
"address",
"rtti",
"2",
"comp",
"address",
"=",
"rtti",
"3",
"address",
"add",
"(",
"rtti",
"2",
"pointer",
"offset",
")",
";",
"address",
"pointed",
"to",
"address",
"=",
"get",
"referenced",
"address",
"(",
"program",
",",
"rtti",
"2",
"comp",
"address",
")",
";",
"if",
"(",
"pointed",
"to",
"address",
"=",
"=",
"null",
"|",
"|",
"!",
"memory",
"contains",
"(",
"pointed",
"to",
"address",
")",
")",
"{",
"return",
"null",
";",
"}",
"return",
"pointed",
"to",
"address",
";",
"}"
]
|
[
"test",
"the",
"property",
"'",
"map",
"map",
"anytype",
"'"
]
| [
"public",
"void",
"map",
"map",
"anytype",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"map",
"map",
"anytype",
"}"
]
|
[
"tests",
"that",
"{",
"@",
"link",
"composite",
"sequenceable",
"loader",
"#",
"continue",
"loading",
"(",
"long",
")",
"}",
"only",
"allows",
"the",
"loader",
"with",
"minimum",
"next",
"load",
"position",
"to",
"continue",
"loading",
"if",
"next",
"load",
"positions",
"are",
"not",
"behind",
"current",
"playback",
"position"
]
| [
"public",
"void",
"continue",
"loading",
"only",
"allow",
"furthest",
"behind",
"loader",
"to",
"load",
"if",
"not",
"behind",
"playback",
"position",
"(",
")",
"{",
"fake",
"sequenceable",
"loader",
"loader",
"1",
"=",
"new",
"fake",
"sequenceable",
"loader",
"(",
"/",
"*",
"buffered",
"position",
"us",
"*",
"/",
"1000",
",",
"/",
"*",
"next",
"load",
"position",
"us",
"*",
"/",
"2000",
")",
";",
"fake",
"sequenceable",
"loader",
"loader",
"2",
"=",
"new",
"fake",
"sequenceable",
"loader",
"(",
"/",
"*",
"buffered",
"position",
"us",
"*",
"/",
"1001",
",",
"/",
"*",
"next",
"load",
"position",
"us",
"*",
"/",
"2001",
")",
";",
"composite",
"sequenceable",
"loader",
"composite",
"sequenceable",
"loader",
"=",
"new",
"composite",
"sequenceable",
"loader",
"(",
"new",
"sequenceable",
"loader",
"[",
"]",
"{",
"loader",
"1",
",",
"loader",
"2",
"}",
")",
";",
"composite",
"sequenceable",
"loader",
"continue",
"loading",
"(",
"100",
")",
";",
"assert",
"that",
"(",
"loader",
"1",
"num",
"invocations",
")",
"is",
"equal",
"to",
"(",
"1",
")",
";",
"assert",
"that",
"(",
"loader",
"2",
"num",
"invocations",
")",
"is",
"equal",
"to",
"(",
"0",
")",
";",
"}"
]
|
[
"get",
"the",
"names",
"of",
"the",
"known",
"repositories",
"which",
"are",
"accessable",
"by",
"the",
"specified",
"user"
]
| [
"public",
"synchronized",
"string",
"[",
"]",
"get",
"repository",
"names",
"(",
"string",
"current",
"user",
")",
"{",
"array",
"list",
"<",
"string",
">",
"list",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"iterator",
"<",
"repository",
">",
"iter",
"=",
"repository",
"map",
"values",
"(",
")",
"iterator",
"(",
")",
";",
"while",
"(",
"iter",
"has",
"next",
"(",
")",
")",
"{",
"repository",
"rep",
"=",
"iter",
"next",
"(",
")",
";",
"if",
"(",
"is",
"anonymous",
"user",
"(",
"current",
"user",
")",
")",
"{",
"if",
"(",
"rep",
"anonymous",
"access",
"allowed",
"(",
")",
")",
"{",
"list",
"add",
"(",
"rep",
"get",
"name",
"(",
")",
")",
";",
"}",
"}",
"else",
"if",
"(",
"rep",
"get",
"user",
"(",
"current",
"user",
")",
"!",
"=",
"null",
")",
"{",
"list",
"add",
"(",
"rep",
"get",
"name",
"(",
")",
")",
";",
"}",
"}",
"collections",
"sort",
"(",
"list",
")",
";",
"string",
"[",
"]",
"names",
"=",
"new",
"string",
"[",
"list",
"size",
"(",
")",
"]",
";",
"return",
"list",
"to",
"array",
"(",
"names",
")",
";",
"}"
]
|
[
"the",
"current",
"mb",
"per",
"second",
"rate",
"limit",
"for",
"this",
"merge"
]
| [
"public",
"static",
"double",
"get",
"mb",
"per",
"sec",
"(",
"thread",
"thread",
",",
"merge",
"policy",
"one",
"merge",
"merge",
")",
"{",
"if",
"(",
"thread",
"instanceof",
"concurrent",
"merge",
"scheduler",
"merge",
"thread",
")",
"{",
"return",
"(",
"(",
"concurrent",
"merge",
"scheduler",
"merge",
"thread",
")",
"thread",
")",
"rate",
"limiter",
"get",
"m",
"b",
"per",
"sec",
"(",
")",
";",
"}",
"assert",
"false",
":",
"\"",
"this",
"is",
"not",
"merge",
"thread",
"\"",
";",
"return",
"double",
"positive",
"infinity",
";",
"}"
]
|
[
"schedules",
"a",
"build",
"of",
"this",
"project",
",",
"and",
"returns",
"a",
"{",
"@",
"link",
"future",
"}",
"object",
"to",
"wait",
"for",
"the",
"completion",
"of",
"the",
"build"
]
| [
"public",
"queue",
"task",
"future",
"<",
"r",
">",
"schedule",
"build",
"2",
"(",
"int",
"quiet",
"period",
",",
"cause",
"c",
",",
"collection",
"<",
"?",
"extends",
"action",
">",
"actions",
")",
"{",
"list",
"<",
"action",
">",
"queue",
"actions",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"actions",
")",
";",
"if",
"(",
"c",
"!",
"=",
"null",
")",
"{",
"queue",
"actions",
"add",
"(",
"new",
"cause",
"action",
"(",
"c",
")",
")",
";",
"}",
"return",
"schedule",
"build",
"2",
"(",
"quiet",
"period",
",",
"queue",
"actions",
"to",
"array",
"(",
"new",
"action",
"[",
"0",
"]",
")",
")",
";",
"}"
]
|
[
"sets",
"the",
"replacement",
"string",
"for",
"any",
"characters",
"outside",
"the",
"'",
"safe",
"'",
"range",
"that",
"have",
"no",
"explicit",
"replacement",
"if",
"{",
"@",
"code",
"unsafe",
"replacement",
"}",
"is",
"{",
"@",
"code",
"null",
"}",
"then",
"no",
"replacement",
"will",
"occur",
",",
"if",
"it",
"is",
"{",
"@",
"code",
"\"",
"\"",
"}",
"then",
"the",
"unsafe",
"characters",
"are",
"removed",
"from",
"the",
"output"
]
| [
"public",
"builder",
"set",
"unsafe",
"replacement",
"(",
"@",
"nullable",
"decl",
"string",
"unsafe",
"replacement",
")",
"{",
"this",
"unsafe",
"replacement",
"=",
"unsafe",
"replacement",
";",
"return",
"this",
";",
"}"
]
|
[
"required",
"to",
"support",
"serialization",
"replaces",
"with",
"canonical",
"instance",
"on",
"deserialization",
",",
"protecting",
"singleton",
"pattern",
"alternative",
"to",
"overriding",
"{",
"@",
"code",
"equals",
"(",
")",
"}"
]
| [
"private",
"object",
"read",
"resolve",
"(",
")",
"{",
"return",
"instance",
";",
"}"
]
|
[
"get",
"class",
"name"
]
| [
"public",
"string",
"get",
"class",
"name",
"(",
")",
"{",
"return",
"class",
"name",
";",
"}"
]
|
[
"gets",
"a",
"mutable",
"copy",
"of",
"the",
"register",
"set",
"associated",
"with",
"the",
"start",
"of",
"the",
"block",
"with",
"the",
"given",
"label",
"this",
"returns",
"a",
"newly",
"-",
"allocated",
"empty",
"{",
"@",
"link",
"register",
"spec",
"set",
"}",
"of",
"appropriate",
"max",
"size",
"if",
"there",
"is",
"not",
"yet",
"any",
"set",
"associated",
"with",
"the",
"block"
]
| [
"public",
"register",
"spec",
"set",
"mutable",
"copy",
"of",
"starts",
"(",
"int",
"label",
")",
"{",
"register",
"spec",
"set",
"result",
"=",
"get",
"starts",
"0",
"(",
"label",
")",
";",
"return",
"(",
"result",
"!",
"=",
"null",
")",
"?",
"result",
"mutable",
"copy",
"(",
")",
":",
"new",
"register",
"spec",
"set",
"(",
"reg",
"count",
")",
";",
"}"
]
|
[
"a",
"visitation",
"over",
"all",
"the",
"nodes",
"in",
"the",
"graph",
"that",
"invokes",
"<",
"code",
">",
"visitor",
"visit",
"node",
"(",
")",
"<",
"code",
">",
"for",
"each",
"node",
"in",
"a",
"depth",
"-",
"first",
"post",
"-",
"order",
":",
"each",
"node",
"is",
"visited",
"after",
"each",
"of",
"its",
"successors",
";",
"the",
"order",
"in",
"which",
"edges",
"are",
"traversed",
"is",
"the",
"order",
"in",
"which",
"they",
"were",
"added",
"to",
"the",
"graph",
"<",
"code",
">",
"visitor",
"visit",
"edge",
"(",
")",
"<",
"code",
">",
"is",
"not",
"called"
]
| [
"public",
"void",
"visit",
"postorder",
"(",
"graph",
"visitor",
"<",
"t",
">",
"visitor",
",",
"iterable",
"<",
"node",
"<",
"t",
">",
">",
"start",
"nodes",
")",
"{",
"visit",
"depth",
"first",
"(",
"visitor",
",",
"dfs",
"order",
"postorder",
",",
"false",
",",
"start",
"nodes",
")",
";",
"}"
]
|
[
"exports",
"the",
"documents"
]
| [
"void",
"execute",
"export",
"(",
"final",
"collection",
"<",
"monitoring",
"doc",
">",
"docs",
",",
"final",
"long",
"start",
"time",
"nanos",
",",
"final",
"action",
"listener",
"<",
"monitoring",
"bulk",
"response",
">",
"delegate",
")",
"{",
"thread",
"pool",
"executor",
"(",
"thread",
"pool",
"names",
"generic",
")",
"execute",
"(",
"new",
"action",
"runnable",
"<",
"monitoring",
"bulk",
"response",
">",
"(",
"delegate",
")",
"{",
"@",
"override",
"protected",
"void",
"do",
"run",
"(",
")",
"{",
"export",
"service",
"export",
"(",
"docs",
",",
"action",
"listener",
"wrap",
"(",
"r",
"-",
">",
"listener",
"on",
"response",
"(",
"response",
"(",
"start",
"time",
"nanos",
")",
")",
",",
"this",
":",
":",
"on",
"failure",
")",
")",
";",
"}",
"@",
"override",
"public",
"void",
"on",
"failure",
"(",
"exception",
"e",
")",
"{",
"listener",
"on",
"response",
"(",
"response",
"(",
"start",
"time",
"nanos",
",",
"e",
")",
")",
";",
"}",
"}",
")",
";",
"}"
]
|
[
"sets",
"if",
"the",
"rollover",
"should",
"not",
"be",
"executed",
"when",
"conditions",
"are",
"met"
]
| [
"public",
"rollover",
"request",
"dry",
"run",
"(",
"boolean",
"dry",
"run",
")",
"{",
"this",
"dry",
"run",
"=",
"dry",
"run",
";",
"return",
"this",
";",
"}"
]
|
[
"mark",
"the",
"specified",
"disallowed",
"field",
"as",
"suppressed",
"the",
"data",
"binder",
"invokes",
"this",
"for",
"each",
"field",
"value",
"that",
"was",
"detected",
"to",
"target",
"a",
"disallowed",
"field"
]
| [
"public",
"void",
"record",
"suppressed",
"field",
"(",
"string",
"field",
")",
"{",
"this",
"suppressed",
"fields",
"add",
"(",
"field",
")",
";",
"}"
]
|
[
"get",
"queue",
"name"
]
| [
"public",
"string",
"get",
"queue",
"name",
"(",
")",
"{",
"return",
"queue",
"name",
";",
"}"
]
|
[
"inverse",
"of",
"{",
"@",
"link",
"#",
"has",
"visible",
"drawable",
"(",
"drawable",
")",
"}"
]
| [
"public",
"component",
"assert",
"does",
"not",
"have",
"visible",
"drawable",
"(",
"drawable",
"drawable",
")",
"{",
"assert",
"that",
"litho",
"view",
"(",
")",
"does",
"not",
"have",
"visible",
"drawable",
"(",
"drawable",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"sets",
"the",
"{",
"@",
"code",
"generation",
"message",
"}",
"and",
"returns",
"a",
"reference",
"to",
"this",
"builder",
"so",
"that",
"the",
"methods",
"can",
"be",
"chained",
"together"
]
| [
"public",
"builder",
"generation",
"message",
"(",
"string",
"generation",
"message",
")",
"{",
"this",
"generation",
"message",
"=",
"generation",
"message",
";",
"return",
"this",
";",
"}"
]
|
[
"similar",
"to",
"{",
"@",
"link",
"#",
"get",
"all",
"items",
"(",
"item",
"group",
",",
"class",
")",
"}",
"but",
"with",
"a",
"predicate",
"to",
"pre",
"-",
"filter",
"items",
"to",
"avoid",
"checking",
"a",
"c",
"ls",
"unnecessarily",
"and",
"returning",
"items",
"not",
"required",
"by",
"the",
"caller"
]
| [
"public",
"static",
"<",
"t",
"extends",
"item",
">",
"list",
"<",
"t",
">",
"get",
"all",
"items",
"(",
"final",
"item",
"group",
"root",
",",
"class",
"<",
"t",
">",
"type",
",",
"predicate",
"<",
"t",
">",
"pred",
")",
"{",
"list",
"<",
"t",
">",
"r",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"get",
"all",
"items",
"(",
"root",
",",
"type",
",",
"r",
",",
"pred",
")",
";",
"return",
"r",
";",
"}"
]
|
[
"get",
"dubbo",
"channel",
"by",
"netty",
"channel",
"through",
"channel",
"cache",
"put",
"netty",
"channel",
"into",
"it",
"if",
"dubbo",
"channel",
"don",
"'",
"t",
"exist",
"in",
"the",
"cache"
]
| [
"static",
"netty",
"channel",
"get",
"or",
"add",
"channel",
"(",
"channel",
"ch",
",",
"url",
"url",
",",
"channel",
"handler",
"handler",
")",
"{",
"if",
"(",
"ch",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"netty",
"channel",
"ret",
"=",
"channel",
"map",
"get",
"(",
"ch",
")",
";",
"if",
"(",
"ret",
"=",
"=",
"null",
")",
"{",
"netty",
"channel",
"netty",
"channel",
"=",
"new",
"netty",
"channel",
"(",
"ch",
",",
"url",
",",
"handler",
")",
";",
"if",
"(",
"ch",
"is",
"active",
"(",
")",
")",
"{",
"netty",
"channel",
"mark",
"active",
"(",
"true",
")",
";",
"ret",
"=",
"channel",
"map",
"put",
"if",
"absent",
"(",
"ch",
",",
"netty",
"channel",
")",
";",
"}",
"if",
"(",
"ret",
"=",
"=",
"null",
")",
"{",
"ret",
"=",
"netty",
"channel",
";",
"}",
"}",
"return",
"ret",
";",
"}"
]
|
[
"do",
"subtraction",
"on",
"date",
"string"
]
| [
"public",
"static",
"string",
"date",
"sub",
"(",
"long",
"ts",
",",
"int",
"days",
",",
"time",
"zone",
"tz",
")",
"{",
"zone",
"id",
"zone",
"id",
"=",
"tz",
"to",
"zone",
"id",
"(",
")",
";",
"instant",
"instant",
"=",
"instant",
"of",
"epoch",
"milli",
"(",
"ts",
")",
";",
"zoned",
"date",
"time",
"zdt",
"=",
"zoned",
"date",
"time",
"of",
"instant",
"(",
"instant",
",",
"zone",
"id",
")",
";",
"long",
"result",
"ts",
"=",
"zdt",
"minus",
"days",
"(",
"days",
")",
"to",
"instant",
"(",
")",
"to",
"epoch",
"milli",
"(",
")",
";",
"return",
"date",
"format",
"(",
"result",
"ts",
",",
"date",
"format",
"string",
",",
"tz",
")",
";",
"}"
]
|
[
"creates",
"a",
"new",
"listenable",
"future",
"-",
"style",
"stub",
"that",
"supports",
"unary",
"calls",
"on",
"the",
"service"
]
| [
"public",
"static",
"xds",
"update",
"health",
"service",
"future",
"stub",
"new",
"future",
"stub",
"(",
"io",
"grpc",
"channel",
"channel",
")",
"{",
"io",
"grpc",
"stub",
"abstract",
"stub",
"stub",
"factory",
"<",
"xds",
"update",
"health",
"service",
"future",
"stub",
">",
"factory",
"=",
"new",
"io",
"grpc",
"stub",
"abstract",
"stub",
"stub",
"factory",
"<",
"xds",
"update",
"health",
"service",
"future",
"stub",
">",
"(",
")",
"{",
"@",
"java",
"lang",
"override",
"public",
"xds",
"update",
"health",
"service",
"future",
"stub",
"new",
"stub",
"(",
"io",
"grpc",
"channel",
"channel",
",",
"io",
"grpc",
"call",
"options",
"call",
"options",
")",
"{",
"return",
"new",
"xds",
"update",
"health",
"service",
"future",
"stub",
"(",
"channel",
",",
"call",
"options",
")",
";",
"}",
"}",
";",
"return",
"xds",
"update",
"health",
"service",
"future",
"stub",
"new",
"stub",
"(",
"factory",
",",
"channel",
")",
";",
"}"
]
|
[
"switches",
"the",
"{",
"@",
"link",
"thread",
"#",
"get",
"context",
"class",
"loader",
"(",
")",
"context",
"class",
"loader",
"}",
"for",
"the",
"managed",
"resources",
"{",
"@",
"link",
"class",
"loader",
"}",
"before",
"allowing",
"the",
"invocation",
"to",
"occur"
]
| [
"public",
"attribute",
"list",
"set",
"attributes",
"(",
"attribute",
"list",
"attributes",
")",
"{",
"class",
"loader",
"current",
"class",
"loader",
"=",
"thread",
"current",
"thread",
"(",
")",
"get",
"context",
"class",
"loader",
"(",
")",
";",
"try",
"{",
"thread",
"current",
"thread",
"(",
")",
"set",
"context",
"class",
"loader",
"(",
"this",
"managed",
"resource",
"class",
"loader",
")",
";",
"return",
"super",
"set",
"attributes",
"(",
"attributes",
")",
";",
"}",
"finally",
"{",
"thread",
"current",
"thread",
"(",
")",
"set",
"context",
"class",
"loader",
"(",
"current",
"class",
"loader",
")",
";",
"}",
"}"
]
|
[
"return",
"the",
"response",
"that",
"{",
"@",
"link",
"#",
"do",
"filter",
"}",
"has",
"been",
"called",
"with"
]
| [
"public",
"servlet",
"response",
"get",
"response",
"(",
")",
"{",
"return",
"this",
"response",
";",
"}"
]
|
[
"creates",
"a",
"{",
"@",
"link",
"private",
"key",
"}",
"from",
"the",
"contents",
"of",
"{",
"@",
"code",
"b",
"reader",
"}",
"that",
"contains",
"an",
"rsa",
"private",
"key",
"encoded",
"in",
"open",
"s",
"s",
"l",
"traditional",
"format"
]
| [
"private",
"static",
"private",
"key",
"parse",
"p",
"k",
"c",
"s",
"1",
"rsa",
"(",
"buffered",
"reader",
"b",
"reader",
",",
"supplier",
"<",
"char",
"[",
"]",
">",
"password",
"supplier",
")",
"throws",
"i",
"o",
"exception",
",",
"general",
"security",
"exception",
"{",
"string",
"builder",
"sb",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"string",
"line",
"=",
"b",
"reader",
"read",
"line",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"pem",
"headers",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"while",
"(",
"line",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"pkcs1",
"footer",
"equals",
"(",
"line",
"trim",
"(",
")",
")",
")",
"{",
"/",
"/",
"unencrypted",
"break",
";",
"}",
"/",
"/",
"parse",
"pem",
"headers",
"according",
"to",
"https",
":",
"/",
"/",
"www",
"ietf",
"org",
"/",
"rfc",
"/",
"rfc",
"1",
"4",
"2",
"1",
"txt",
"if",
"(",
"line",
"contains",
"(",
"\"",
":",
"\"",
")",
")",
"{",
"string",
"[",
"]",
"header",
"=",
"line",
"split",
"(",
"\"",
":",
"\"",
")",
";",
"pem",
"headers",
"put",
"(",
"header",
"[",
"0",
"]",
"trim",
"(",
")",
",",
"header",
"[",
"1",
"]",
"trim",
"(",
")",
")",
";",
"}",
"else",
"{",
"sb",
"append",
"(",
"line",
"trim",
"(",
")",
")",
";",
"}",
"line",
"=",
"b",
"reader",
"read",
"line",
"(",
")",
";",
"}",
"if",
"(",
"null",
"=",
"=",
"line",
"|",
"|",
"pkcs1",
"footer",
"equals",
"(",
"line",
"trim",
"(",
")",
")",
"=",
"=",
"false",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"malformed",
"pem",
"file",
",",
"pem",
"footer",
"is",
"invalid",
"or",
"missing",
"\"",
")",
";",
"}",
"byte",
"[",
"]",
"key",
"bytes",
"=",
"possibly",
"decrypt",
"p",
"k",
"c",
"s",
"1",
"key",
"(",
"pem",
"headers",
",",
"sb",
"to",
"string",
"(",
")",
",",
"password",
"supplier",
")",
";",
"r",
"s",
"a",
"private",
"crt",
"key",
"spec",
"spec",
"=",
"parse",
"rsa",
"der",
"(",
"key",
"bytes",
")",
";",
"key",
"factory",
"key",
"factory",
"=",
"key",
"factory",
"get",
"instance",
"(",
"\"",
"rsa",
"\"",
")",
";",
"return",
"key",
"factory",
"generate",
"private",
"(",
"spec",
")",
";",
"}"
]
|
[
"calculates",
"the",
"sleep",
"time",
"for",
"full",
"jitter",
"based",
"on",
"the",
"given",
"parameters"
]
| [
"public",
"long",
"calculate",
"full",
"jitter",
"backoff",
"(",
"long",
"base",
"millis",
",",
"long",
"max",
"millis",
",",
"double",
"power",
",",
"int",
"attempt",
")",
"{",
"long",
"exponential",
"backoff",
"=",
"(",
"long",
")",
"math",
"min",
"(",
"max",
"millis",
",",
"base",
"millis",
"*",
"math",
"pow",
"(",
"power",
",",
"attempt",
")",
")",
";",
"return",
"(",
"long",
")",
"(",
"seed",
"next",
"double",
"(",
")",
"*",
"exponential",
"backoff",
")",
";",
"}"
]
|
[
"convenience",
"method",
"to",
"link",
"multiple",
"tools",
"same",
"as",
"calling",
"{",
"@",
"link",
"#",
"link",
"tool",
"(",
"string",
")",
"}",
"for",
"each",
"parameter"
]
| [
"public",
"void",
"link",
"tools",
"(",
"string",
"tools",
")",
"throws",
"i",
"o",
"exception",
"{",
"for",
"(",
"string",
"tool",
":",
"tools",
")",
"{",
"link",
"tool",
"(",
"tool",
")",
";",
"}",
"}"
]
|
[
"this",
"method",
"is",
"called",
"when",
"an",
"attempt",
"to",
"register",
"a",
"channel",
"throws",
"an",
"exception"
]
| [
"protected",
"void",
"registration",
"exception",
"(",
"channel",
"context",
"<",
"?",
">",
"context",
",",
"exception",
"exception",
")",
"{",
"context",
"handle",
"exception",
"(",
"exception",
")",
";",
"}"
]
|
[
"returns",
"an",
"index",
"that",
"will",
"always",
"be",
"associated",
"to",
"the",
"given",
"key",
"as",
"long",
"as",
"the",
"key",
"remains",
"in",
"the",
"table",
"if",
"the",
"key",
"already",
"exists",
",",
"then",
"the",
"index",
"where",
"that",
"key",
"is",
"stored",
"is",
"returned",
"if",
"the",
"key",
"is",
"new",
",",
"then",
"a",
"new",
"index",
"is",
"allocated",
",",
"the",
"key",
"is",
"stored",
"at",
"that",
"index",
",",
"and",
"the",
"new",
"index",
"is",
"returned"
]
| [
"public",
"int",
"put",
"(",
"int",
"key",
")",
"{",
"/",
"/",
"check",
"if",
"the",
"key",
"already",
"exists",
"int",
"index",
"=",
"find",
"key",
"(",
"key",
")",
";",
"/",
"/",
"if",
"not",
",",
"then",
"we",
"need",
"to",
"add",
"it",
"if",
"(",
"index",
"=",
"=",
"-",
"1",
")",
"{",
"/",
"/",
"make",
"sure",
"there",
"is",
"enough",
"room",
"if",
"(",
"indexer",
"get",
"size",
"(",
")",
">",
"=",
"capacity",
")",
"{",
"/",
"/",
"if",
"not",
"enough",
"room",
",",
"grow",
"the",
"key",
"capacity",
"grow",
"(",
")",
";",
"}",
"/",
"/",
"now",
"use",
"the",
"hashcode",
"as",
"the",
"list",
"i",
"d",
"and",
"get",
"a",
"new",
"index",
"/",
"/",
"to",
"put",
"on",
"that",
"list",
"then",
"store",
"the",
"key",
"at",
"the",
"new",
"index",
"int",
"hashcode",
"=",
"(",
"key",
"&",
"0x",
"7fffffff",
")",
"%",
"capacity",
";",
"index",
"=",
"indexer",
"add",
"(",
"hashcode",
")",
";",
"if",
"(",
"index",
"<",
"0",
")",
"{",
"throw",
"new",
"index",
"out",
"of",
"bounds",
"exception",
"(",
"\"",
"maximum",
"capacity",
"reached",
"\"",
")",
";",
"}",
"keys",
"[",
"index",
"]",
"=",
"key",
";",
"}",
"/",
"/",
"return",
"the",
"index",
"associated",
"with",
"the",
"given",
"key",
"return",
"index",
";",
"}"
]
|
[
"join",
"an",
"array",
"of",
"strings",
"with",
"the",
"given",
"separator",
"note",
":",
"this",
"might",
"be",
"replaced",
"by",
"utility",
"method",
"from",
"commons",
"-",
"lang",
"or",
"guava",
"someday",
"if",
"one",
"of",
"those",
"libraries",
"is",
"added",
"as",
"dependency"
]
| [
"public",
"static",
"string",
"join",
"(",
"string",
"[",
"]",
"array",
",",
"string",
"separator",
")",
"{",
"int",
"len",
"=",
"array",
"length",
";",
"if",
"(",
"len",
"=",
"=",
"0",
")",
"{",
"return",
"\"",
"\"",
";",
"}",
"string",
"builder",
"out",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"out",
"append",
"(",
"array",
"[",
"0",
"]",
")",
";",
"for",
"(",
"int",
"i",
"=",
"1",
";",
"i",
"<",
"len",
";",
"i",
"+",
"+",
")",
"{",
"out",
"append",
"(",
"separator",
")",
"append",
"(",
"array",
"[",
"i",
"]",
")",
";",
"}",
"return",
"out",
"to",
"string",
"(",
")",
";",
"}"
]
|
[
"create",
"a",
"default",
"strategy",
"the",
"default",
"implementation",
"uses",
"{",
"@",
"link",
"org",
"springframework",
"beans",
"factory",
"config",
"autowire",
"capable",
"bean",
"factory",
"#",
"create",
"bean",
"}"
]
| [
"protected",
"object",
"create",
"default",
"strategy",
"(",
"application",
"context",
"context",
",",
"class",
"<",
"?",
">",
"clazz",
")",
"{",
"return",
"context",
"get",
"autowire",
"capable",
"bean",
"factory",
"(",
")",
"create",
"bean",
"(",
"clazz",
")",
";",
"}"
]
|
[
"called",
"when",
"the",
"audio",
"capabilities",
"change"
]
| [
"void",
"on",
"audio",
"capabilities",
"changed",
"(",
"audio",
"capabilities",
"audio",
"capabilities",
")",
";"
]
|
[
"returns",
"the",
"current",
"frame",
"number"
]
| [
"public",
"int",
"get",
"key",
"frame",
"index",
"(",
"float",
"state",
"time",
")",
"{",
"if",
"(",
"key",
"frames",
"length",
"=",
"=",
"1",
")",
"return",
"0",
";",
"int",
"frame",
"number",
"=",
"(",
"int",
")",
"(",
"state",
"time",
"/",
"frame",
"duration",
")",
";",
"switch",
"(",
"play",
"mode",
")",
"{",
"case",
"normal",
":",
"frame",
"number",
"=",
"math",
"min",
"(",
"key",
"frames",
"length",
"-",
"1",
",",
"frame",
"number",
")",
";",
"break",
";",
"case",
"loop",
":",
"frame",
"number",
"=",
"frame",
"number",
"%",
"key",
"frames",
"length",
";",
"break",
";",
"case",
"loop",
"pingpong",
":",
"frame",
"number",
"=",
"frame",
"number",
"%",
"(",
"(",
"key",
"frames",
"length",
"*",
"2",
")",
"-",
"2",
")",
";",
"if",
"(",
"frame",
"number",
">",
"=",
"key",
"frames",
"length",
")",
"frame",
"number",
"=",
"key",
"frames",
"length",
"-",
"2",
"-",
"(",
"frame",
"number",
"-",
"key",
"frames",
"length",
")",
";",
"break",
";",
"case",
"loop",
"random",
":",
"int",
"last",
"frame",
"number",
"=",
"(",
"int",
")",
"(",
"(",
"last",
"state",
"time",
")",
"/",
"frame",
"duration",
")",
";",
"if",
"(",
"last",
"frame",
"number",
"!",
"=",
"frame",
"number",
")",
"{",
"frame",
"number",
"=",
"math",
"utils",
"random",
"(",
"key",
"frames",
"length",
"-",
"1",
")",
";",
"}",
"else",
"{",
"frame",
"number",
"=",
"this",
"last",
"frame",
"number",
";",
"}",
"break",
";",
"case",
"reversed",
":",
"frame",
"number",
"=",
"math",
"max",
"(",
"key",
"frames",
"length",
"-",
"frame",
"number",
"-",
"1",
",",
"0",
")",
";",
"break",
";",
"case",
"loop",
"reversed",
":",
"frame",
"number",
"=",
"frame",
"number",
"%",
"key",
"frames",
"length",
";",
"frame",
"number",
"=",
"key",
"frames",
"length",
"-",
"frame",
"number",
"-",
"1",
";",
"break",
";",
"}",
"last",
"frame",
"number",
"=",
"frame",
"number",
";",
"last",
"state",
"time",
"=",
"state",
"time",
";",
"return",
"frame",
"number",
";",
"}"
]
|
[
"does",
"the",
"translation",
"and",
"returns",
"the",
"result"
]
| [
"private",
"dalv",
"code",
"translate",
"and",
"get",
"result",
"(",
")",
"{",
"pick",
"order",
"(",
")",
";",
"output",
"instructions",
"(",
")",
";",
"std",
"catch",
"builder",
"catches",
"=",
"new",
"std",
"catch",
"builder",
"(",
"method",
",",
"order",
",",
"addresses",
")",
";",
"return",
"new",
"dalv",
"code",
"(",
"position",
"info",
",",
"output",
"get",
"finisher",
"(",
")",
",",
"catches",
")",
";",
"}"
]
|
[
"wrap",
"a",
"command",
"in",
"a",
"shell",
"to",
"capture",
"stdout",
"and",
"stderr",
"to",
"files",
"setup",
"commands",
"such",
"as",
"setting",
"memory",
"limit",
"can",
"be",
"passed",
"which",
"will",
"be",
"executed",
"before",
"exec",
"if",
"the",
"tail",
"length",
"is",
"0",
",",
"the",
"entire",
"output",
"will",
"be",
"saved"
]
| [
"public",
"static",
"list",
"<",
"string",
">",
"capture",
"out",
"and",
"error",
"(",
"list",
"<",
"string",
">",
"setup",
",",
"list",
"<",
"string",
">",
"cmd",
",",
"file",
"stdout",
"filename",
",",
"file",
"stderr",
"filename",
",",
"long",
"tail",
"length",
",",
"boolean",
"use",
"setsid",
")",
"throws",
"i",
"o",
"exception",
"{",
"list",
"<",
"string",
">",
"result",
"=",
"new",
"array",
"list",
"<",
"string",
">",
"(",
"3",
")",
";",
"result",
"add",
"(",
"bash",
"command",
")",
";",
"result",
"add",
"(",
"\"",
"-",
"c",
"\"",
")",
";",
"string",
"merged",
"cmd",
"=",
"build",
"command",
"line",
"(",
"setup",
",",
"cmd",
",",
"stdout",
"filename",
",",
"stderr",
"filename",
",",
"tail",
"length",
",",
"use",
"setsid",
")",
";",
"result",
"add",
"(",
"merged",
"cmd",
")",
";",
"return",
"result",
";",
"}"
]
|
[
"sets",
"the",
"destination",
"domain",
"folder"
]
| [
"void",
"set",
"folder",
"(",
"domain",
"folder",
"folder",
")",
"{",
"this",
"folder",
"=",
"folder",
";",
"if",
"(",
"folder",
"!",
"=",
"null",
")",
"{",
"folder",
"name",
"field",
"set",
"text",
"(",
"folder",
"to",
"string",
"(",
")",
")",
";",
"}",
"else",
"{",
"folder",
"name",
"field",
"set",
"text",
"(",
"\"",
"<",
"choose",
"a",
"folder",
">",
"\"",
")",
";",
"}",
"notify",
"listeners",
"of",
"validity",
"changed",
"(",
")",
";",
"}"
]
|
[
"this",
"method",
"is",
"called",
"for",
"each",
"element",
"in",
"the",
"first",
"of",
"the",
"connected",
"streams",
"this",
"function",
"can",
"output",
"zero",
"or",
"more",
"elements",
"using",
"the",
"{",
"@",
"link",
"collector",
"}",
"parameter",
"and",
"also",
"update",
"internal",
"state",
"or",
"set",
"timers",
"using",
"the",
"{",
"@",
"link",
"context",
"}",
"parameter"
]
| [
"public",
"abstract",
"void",
"process",
"element",
"1",
"(",
"in1",
"value",
",",
"context",
"ctx",
",",
"collector",
"<",
"out",
">",
"out",
")",
"throws",
"exception",
";"
]
|
[
"creates",
"a",
"fresh",
"completable",
"subject"
]
| [
"public",
"static",
"completable",
"subject",
"create",
"(",
")",
"{",
"return",
"new",
"completable",
"subject",
"(",
")",
";",
"}"
]
|
[
"get",
"the",
"{",
"@",
"link",
"pattern",
"info",
"row",
"object",
"}",
"for",
"this",
"closed",
"pattern"
]
| [
"public",
"pattern",
"info",
"row",
"object",
"get",
"pattern",
"info",
"(",
")",
"{",
"return",
"pattern",
"info",
";",
"}"
]
|
[
"read",
"{",
"@",
"code",
"v",
"}",
"-",
"type",
"value",
"from",
"a",
"stream"
]
| [
"v",
"read",
"(",
"stream",
"input",
"in",
")",
"throws",
"i",
"o",
"exception",
";"
]
|
[
"get",
"the",
"second",
"fixture",
"in",
"this",
"contact"
]
| [
"public",
"fixture",
"get",
"fixture",
"b",
"(",
")",
"{",
"return",
"world",
"fixtures",
"get",
"(",
"contact",
"m",
"fixture",
"b",
")",
";",
"}"
]
|
[
"release",
"a",
"key",
"on",
"the",
"keyboard",
"that",
"isn",
"'",
"t",
"text",
"please",
"see",
"{",
"@",
"link",
"org",
"openqa",
"selenium",
"keys",
"}",
"for",
"an",
"exhaustive",
"list",
"of",
"recognized",
"pressable",
"keys",
"if",
"<",
"code",
">",
"key",
"to",
"release",
"<",
"code",
">",
"is",
"a",
"sequence",
"of",
"characters",
",",
"different",
"driver",
"implementations",
"may",
"choose",
"to",
"throw",
"an",
"exception",
"or",
"to",
"read",
"only",
"the",
"first",
"character",
"in",
"the",
"sequence"
]
| [
"void",
"release",
"key",
"(",
"char",
"sequence",
"key",
"to",
"release",
")",
";"
]
|
[
"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",
"\"",
")",
";",
"}"
]
|
[
"return",
"the",
"specified",
"persistence",
"unit",
"info",
"from",
"this",
"manager",
"'",
"s",
"cache",
"of",
"processed",
"persistence",
"units",
",",
"keeping",
"it",
"in",
"the",
"cache",
"(",
"i",
"e",
"not",
"'",
"obtaining",
"'",
"it",
"for",
"use",
"but",
"rather",
"just",
"accessing",
"it",
"for",
"post",
"-",
"processing",
")",
"this",
"can",
"be",
"used",
"in",
"{",
"@",
"link",
"#",
"post",
"process",
"persistence",
"unit",
"info",
"}",
"implementations",
",",
"detecting",
"existing",
"persistence",
"units",
"of",
"the",
"same",
"name",
"and",
"potentially",
"merging",
"them"
]
| [
"protected",
"final",
"mutable",
"persistence",
"unit",
"info",
"get",
"persistence",
"unit",
"info",
"(",
"string",
"persistence",
"unit",
"name",
")",
"{",
"persistence",
"unit",
"info",
"pui",
"=",
"this",
"persistence",
"unit",
"infos",
"get",
"(",
"persistence",
"unit",
"name",
")",
";",
"return",
"(",
"mutable",
"persistence",
"unit",
"info",
")",
"pui",
";",
"}"
]
|
[
"creates",
"an",
"hourly",
"schedule"
]
| [
"public",
"static",
"hourly",
"schedule",
"hourly",
"(",
"int",
"minutes",
")",
"{",
"return",
"new",
"hourly",
"schedule",
"(",
"minutes",
")",
";",
"}"
]
|
[
"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",
"next",
"parent",
"layout",
"$",
"still",
"no",
"layout",
"on",
"visibility",
"state",
"changed",
"(",
"on",
"model",
"visibility",
"state",
"changed",
"listener",
"<",
"generate",
"default",
"layout",
"method",
"next",
"parent",
"layout",
"$",
"still",
"no",
"layout",
",",
"object",
">",
"listener",
")",
"{",
"on",
"mutation",
"(",
")",
";",
"this",
"on",
"model",
"visibility",
"state",
"changed",
"listener",
"epoxy",
"generated",
"model",
"=",
"listener",
";",
"return",
"this",
";",
"}"
]
|
[
"since",
"message",
"headers",
"are",
"immutable",
",",
"the",
"call",
"to",
"this",
"method",
"will",
"result",
"in",
"{",
"@",
"link",
"unsupported",
"operation",
"exception",
"}"
]
| [
"public",
"object",
"remove",
"(",
"object",
"key",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
"\"",
"message",
"headers",
"is",
"immutable",
"\"",
")",
";",
"}"
]
|
[
"test",
"verifies",
"watcher",
"type",
"children",
"-",
"removes",
"only",
"the",
"configured",
"child",
"watcher",
"function"
]
| [
"public",
"void",
"test",
"remove",
"when",
"multiple",
"child",
"watches",
"on",
"a",
"path",
"(",
"boolean",
"use",
"async",
")",
"throws",
"exception",
"{",
"zk",
"1",
"create",
"(",
"\"",
"/",
"node",
"1",
"\"",
",",
"null",
",",
"ids",
"open",
"acl",
"unsafe",
",",
"create",
"mode",
"persistent",
")",
";",
"final",
"count",
"down",
"latch",
"child",
"watch",
"count",
"=",
"new",
"count",
"down",
"latch",
"(",
"1",
")",
";",
"final",
"count",
"down",
"latch",
"rm",
"watch",
"count",
"=",
"new",
"count",
"down",
"latch",
"(",
"1",
")",
";",
"watcher",
"w",
"1",
"=",
"event",
"-",
">",
"{",
"if",
"(",
"event",
"get",
"type",
"(",
")",
"=",
"=",
"event",
"type",
"child",
"watch",
"removed",
")",
"{",
"rm",
"watch",
"count",
"count",
"down",
"(",
")",
";",
"}",
"}",
";",
"watcher",
"w",
"2",
"=",
"event",
"-",
">",
"{",
"if",
"(",
"event",
"get",
"type",
"(",
")",
"=",
"=",
"event",
"type",
"node",
"children",
"changed",
")",
"{",
"child",
"watch",
"count",
"count",
"down",
"(",
")",
";",
"}",
"}",
";",
"/",
"/",
"add",
"multiple",
"child",
"watches",
"log",
"info",
"(",
"\"",
"adding",
"child",
"watcher",
"{",
"}",
"on",
"path",
"{",
"}",
"\"",
",",
"w",
"1",
",",
"\"",
"/",
"node",
"1",
"\"",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"zk",
"2",
"get",
"children",
"(",
"\"",
"/",
"node",
"1",
"\"",
",",
"w",
"1",
")",
"size",
"(",
")",
",",
"\"",
"didn",
"'",
"t",
"set",
"child",
"watches",
"\"",
")",
";",
"log",
"info",
"(",
"\"",
"adding",
"child",
"watcher",
"{",
"}",
"on",
"path",
"{",
"}",
"\"",
",",
"w",
"2",
",",
"\"",
"/",
"node",
"1",
"\"",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"zk",
"2",
"get",
"children",
"(",
"\"",
"/",
"node",
"1",
"\"",
",",
"w",
"2",
")",
"size",
"(",
")",
",",
"\"",
"didn",
"'",
"t",
"set",
"child",
"watches",
"\"",
")",
";",
"remove",
"watches",
"(",
"zk",
"2",
",",
"\"",
"/",
"node",
"1",
"\"",
",",
"w",
"1",
",",
"watcher",
"type",
"children",
",",
"false",
",",
"code",
"ok",
",",
"use",
"async",
")",
";",
"assert",
"true",
"(",
"rm",
"watch",
"count",
"await",
"(",
"connection",
"timeout",
",",
"time",
"unit",
"milliseconds",
")",
",",
"\"",
"didn",
"'",
"t",
"remove",
"child",
"watcher",
"\"",
")",
";",
"zk",
"1",
"create",
"(",
"\"",
"/",
"node",
"1",
"/",
"node",
"2",
"\"",
",",
"null",
",",
"ids",
"open",
"acl",
"unsafe",
",",
"create",
"mode",
"persistent",
")",
";",
"log",
"info",
"(",
"\"",
"waiting",
"for",
"child",
"watchers",
"to",
"be",
"notified",
"\"",
")",
";",
"assert",
"true",
"(",
"child",
"watch",
"count",
"await",
"(",
"connection",
"timeout",
",",
"time",
"unit",
"milliseconds",
")",
",",
"\"",
"didn",
"'",
"t",
"get",
"child",
"watch",
"notification",
"!",
"\"",
")",
";",
"}"
]
|
[
"convert",
"class",
"descriptor",
"to",
"its",
"binary",
"name"
]
| [
"public",
"static",
"string",
"descriptor",
"to",
"binary",
"name",
"(",
"string",
"descriptor",
")",
"{",
"check",
"argument",
"(",
"is",
"class",
"descriptor",
"(",
"descriptor",
")",
",",
"\"",
"'",
"%",
"s",
"'",
"is",
"not",
"a",
"class",
"descriptor",
"\"",
",",
"descriptor",
")",
";",
"return",
"type",
"get",
"type",
"(",
"descriptor",
")",
"get",
"internal",
"name",
"(",
")",
";",
"}"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.