docstring_tokens
list | code_tokens
list |
|---|---|
[
"selects",
"the",
"nth",
"-",
"lowest",
"element",
"from",
"the",
"array",
"according",
"to",
"comparator",
"ranking",
"this",
"might",
"partially",
"sort",
"the",
"array",
"the",
"array",
"must",
"have",
"a",
"size",
"greater",
"than",
"0",
",",
"or",
"a",
"{",
"@",
"link",
"com",
"badlogic",
"gdx",
"utils",
"gdx",
"runtime",
"exception",
"}",
"will",
"be",
"thrown"
]
| [
"public",
"t",
"select",
"ranked",
"(",
"comparator",
"<",
"t",
">",
"comparator",
",",
"int",
"kth",
"lowest",
")",
"{",
"if",
"(",
"kth",
"lowest",
"<",
"1",
")",
"{",
"throw",
"new",
"gdx",
"runtime",
"exception",
"(",
"\"",
"nth",
"lowest",
"must",
"be",
"greater",
"than",
"0",
",",
"1",
"=",
"first",
",",
"2",
"=",
"second",
"\"",
")",
";",
"}",
"return",
"select",
"instance",
"(",
")",
"select",
"(",
"items",
",",
"comparator",
",",
"kth",
"lowest",
",",
"size",
")",
";",
"}"
]
|
[
"destroys",
"this",
"spring",
",",
"meaning",
"that",
"it",
"will",
"be",
"deregistered",
"from",
"its",
"base",
"spring",
"system",
"so",
"it",
"won",
"'",
"t",
"be",
"iterated",
"anymore",
"and",
"will",
"clear",
"its",
"set",
"of",
"listeners",
"do",
"not",
"use",
"the",
"spring",
"after",
"calling",
"this",
",",
"doing",
"so",
"may",
"just",
"cause",
"an",
"exception",
"to",
"be",
"thrown"
]
| [
"public",
"void",
"destroy",
"(",
")",
"{",
"m",
"listeners",
"clear",
"(",
")",
";",
"}"
]
|
[
"template",
"method",
"that",
"allows",
"for",
"manipulating",
"the",
"{",
"@",
"link",
"http",
"uri",
"request",
"}",
"before",
"it",
"is",
"returned",
"as",
"part",
"of",
"a",
"{",
"@",
"link",
"http",
"components",
"client",
"http",
"request",
"}",
"the",
"default",
"implementation",
"is",
"empty"
]
| [
"protected",
"void",
"post",
"process",
"http",
"request",
"(",
"http",
"uri",
"request",
"request",
")",
"{",
"}"
]
|
[
"reads",
"a",
"new",
"watcher",
"search",
"request",
"instance",
"for",
"the",
"specified",
"parser"
]
| [
"public",
"static",
"watcher",
"search",
"template",
"request",
"from",
"x",
"content",
"(",
"x",
"content",
"parser",
"parser",
",",
"search",
"type",
"search",
"type",
")",
"throws",
"i",
"o",
"exception",
"{",
"list",
"<",
"string",
">",
"indices",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"indices",
"options",
"indices",
"options",
"=",
"default",
"indices",
"options",
";",
"bytes",
"reference",
"search",
"source",
"=",
"null",
";",
"script",
"template",
"=",
"null",
";",
"/",
"/",
"todo",
"this",
"is",
"to",
"retain",
"bwc",
"compatibility",
"in",
"7",
"0",
"and",
"can",
"be",
"removed",
"for",
"8",
"0",
"boolean",
"total",
"hits",
"as",
"int",
"=",
"true",
";",
"x",
"content",
"parser",
"token",
"token",
";",
"string",
"current",
"field",
"name",
"=",
"null",
";",
"while",
"(",
"(",
"token",
"=",
"parser",
"next",
"token",
"(",
")",
")",
"!",
"=",
"x",
"content",
"parser",
"token",
"end",
"object",
")",
"{",
"if",
"(",
"token",
"=",
"=",
"x",
"content",
"parser",
"token",
"field",
"name",
")",
"{",
"current",
"field",
"name",
"=",
"parser",
"current",
"name",
"(",
")",
";",
"}",
"else",
"if",
"(",
"token",
"=",
"=",
"x",
"content",
"parser",
"token",
"start",
"array",
")",
"{",
"if",
"(",
"indices",
"field",
"match",
"(",
"current",
"field",
"name",
",",
"parser",
"get",
"deprecation",
"handler",
"(",
")",
")",
")",
"{",
"while",
"(",
"(",
"token",
"=",
"parser",
"next",
"token",
"(",
")",
")",
"!",
"=",
"x",
"content",
"parser",
"token",
"end",
"array",
")",
"{",
"if",
"(",
"token",
"=",
"=",
"x",
"content",
"parser",
"token",
"value",
"string",
")",
"{",
"indices",
"add",
"(",
"parser",
"text",
"or",
"null",
"(",
")",
")",
";",
"}",
"else",
"{",
"throw",
"new",
"elasticsearch",
"parse",
"exception",
"(",
"\"",
"could",
"not",
"read",
"search",
"request",
"expected",
"string",
"values",
"in",
"[",
"\"",
"+",
"current",
"field",
"name",
"+",
"\"",
"]",
"field",
",",
"but",
"instead",
"found",
"[",
"\"",
"+",
"token",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"}",
"}",
"else",
"{",
"throw",
"new",
"elasticsearch",
"parse",
"exception",
"(",
"\"",
"could",
"not",
"read",
"search",
"request",
"unexpected",
"array",
"field",
"[",
"\"",
"+",
"current",
"field",
"name",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"}",
"else",
"if",
"(",
"token",
"=",
"=",
"x",
"content",
"parser",
"token",
"start",
"object",
")",
"{",
"if",
"(",
"body",
"field",
"match",
"(",
"current",
"field",
"name",
",",
"parser",
"get",
"deprecation",
"handler",
"(",
")",
")",
")",
"{",
"try",
"(",
"x",
"content",
"builder",
"builder",
"=",
"x",
"content",
"factory",
"json",
"builder",
"(",
")",
")",
"{",
"builder",
"copy",
"current",
"structure",
"(",
"parser",
")",
";",
"search",
"source",
"=",
"bytes",
"reference",
"bytes",
"(",
"builder",
")",
";",
"}",
"}",
"else",
"if",
"(",
"indices",
"options",
"field",
"match",
"(",
"current",
"field",
"name",
",",
"parser",
"get",
"deprecation",
"handler",
"(",
")",
")",
")",
"{",
"indices",
"options",
"=",
"indices",
"options",
"from",
"x",
"content",
"(",
"parser",
")",
";",
"}",
"else",
"if",
"(",
"template",
"field",
"match",
"(",
"current",
"field",
"name",
",",
"parser",
"get",
"deprecation",
"handler",
"(",
")",
")",
")",
"{",
"template",
"=",
"script",
"parse",
"(",
"parser",
",",
"script",
"default",
"template",
"lang",
")",
";",
"}",
"else",
"{",
"throw",
"new",
"elasticsearch",
"parse",
"exception",
"(",
"\"",
"could",
"not",
"read",
"search",
"request",
"unexpected",
"object",
"field",
"[",
"\"",
"+",
"current",
"field",
"name",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"}",
"else",
"if",
"(",
"token",
"=",
"=",
"x",
"content",
"parser",
"token",
"value",
"string",
")",
"{",
"if",
"(",
"indices",
"field",
"match",
"(",
"current",
"field",
"name",
",",
"parser",
"get",
"deprecation",
"handler",
"(",
")",
")",
")",
"{",
"string",
"indices",
"str",
"=",
"parser",
"text",
"(",
")",
";",
"indices",
"add",
"all",
"(",
"arrays",
"as",
"list",
"(",
"strings",
"delimited",
"list",
"to",
"string",
"array",
"(",
"indices",
"str",
",",
"\"",
",",
"\"",
",",
"\"",
"\\",
"t",
"\"",
")",
")",
")",
";",
"}",
"else",
"if",
"(",
"search",
"type",
"field",
"match",
"(",
"current",
"field",
"name",
",",
"parser",
"get",
"deprecation",
"handler",
"(",
")",
")",
")",
"{",
"search",
"type",
"=",
"search",
"type",
"from",
"string",
"(",
"parser",
"text",
"(",
")",
"to",
"lower",
"case",
"(",
"locale",
"root",
")",
")",
";",
"}",
"else",
"if",
"(",
"rest",
"total",
"hits",
"as",
"int",
"field",
"match",
"(",
"current",
"field",
"name",
",",
"parser",
"get",
"deprecation",
"handler",
"(",
")",
")",
")",
"{",
"total",
"hits",
"as",
"int",
"=",
"parser",
"boolean",
"value",
"(",
")",
";",
"}",
"else",
"{",
"throw",
"new",
"elasticsearch",
"parse",
"exception",
"(",
"\"",
"could",
"not",
"read",
"search",
"request",
"unexpected",
"string",
"field",
"[",
"\"",
"+",
"current",
"field",
"name",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"}",
"else",
"if",
"(",
"token",
"=",
"=",
"x",
"content",
"parser",
"token",
"value",
"boolean",
")",
"{",
"if",
"(",
"rest",
"total",
"hits",
"as",
"int",
"field",
"match",
"(",
"current",
"field",
"name",
",",
"parser",
"get",
"deprecation",
"handler",
"(",
")",
")",
")",
"{",
"total",
"hits",
"as",
"int",
"=",
"parser",
"boolean",
"value",
"(",
")",
";",
"}",
"else",
"{",
"throw",
"new",
"elasticsearch",
"parse",
"exception",
"(",
"\"",
"could",
"not",
"read",
"search",
"request",
"unexpected",
"boolean",
"field",
"[",
"\"",
"+",
"current",
"field",
"name",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"}",
"else",
"{",
"throw",
"new",
"elasticsearch",
"parse",
"exception",
"(",
"\"",
"could",
"not",
"read",
"search",
"request",
"unexpected",
"token",
"[",
"\"",
"+",
"token",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"}",
"if",
"(",
"search",
"source",
"=",
"=",
"null",
")",
"{",
"search",
"source",
"=",
"bytes",
"array",
"empty",
";",
"}",
"watcher",
"search",
"template",
"request",
"request",
"=",
"new",
"watcher",
"search",
"template",
"request",
"(",
"indices",
"to",
"array",
"(",
"new",
"string",
"[",
"0",
"]",
")",
",",
"search",
"type",
",",
"indices",
"options",
",",
"search",
"source",
",",
"template",
")",
";",
"request",
"set",
"rest",
"total",
"hits",
"as",
"int",
"(",
"total",
"hits",
"as",
"int",
")",
";",
"return",
"request",
";",
"}"
]
|
[
"copy",
"bytes",
"of",
"segments",
"to",
"output",
"view",
"note",
":",
"it",
"just",
"copies",
"the",
"data",
"in",
",",
"not",
"include",
"the",
"length"
]
| [
"public",
"static",
"void",
"copy",
"to",
"view",
"(",
"memory",
"segment",
"[",
"]",
"segments",
",",
"int",
"offset",
",",
"int",
"size",
"in",
"bytes",
",",
"data",
"output",
"view",
"target",
")",
"throws",
"i",
"o",
"exception",
"{",
"for",
"(",
"memory",
"segment",
"source",
"segment",
":",
"segments",
")",
"{",
"int",
"cur",
"seg",
"remain",
"=",
"source",
"segment",
"size",
"(",
")",
"-",
"offset",
";",
"if",
"(",
"cur",
"seg",
"remain",
">",
"0",
")",
"{",
"int",
"copy",
"size",
"=",
"math",
"min",
"(",
"cur",
"seg",
"remain",
",",
"size",
"in",
"bytes",
")",
";",
"byte",
"[",
"]",
"bytes",
"=",
"allocate",
"reuse",
"bytes",
"(",
"copy",
"size",
")",
";",
"source",
"segment",
"get",
"(",
"offset",
",",
"bytes",
",",
"0",
",",
"copy",
"size",
")",
";",
"target",
"write",
"(",
"bytes",
",",
"0",
",",
"copy",
"size",
")",
";",
"size",
"in",
"bytes",
"-",
"=",
"copy",
"size",
";",
"offset",
"=",
"0",
";",
"}",
"else",
"{",
"offset",
"-",
"=",
"source",
"segment",
"size",
"(",
")",
";",
"}",
"if",
"(",
"size",
"in",
"bytes",
"=",
"=",
"0",
")",
"{",
"return",
";",
"}",
"}",
"if",
"(",
"size",
"in",
"bytes",
"!",
"=",
"0",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"no",
"copy",
"finished",
",",
"this",
"should",
"be",
"a",
"bug",
",",
"\"",
"+",
"\"",
"the",
"remaining",
"length",
"is",
":",
"\"",
"+",
"size",
"in",
"bytes",
")",
";",
"}",
"}"
]
|
[
"construct",
"the",
"preferred",
"type",
"of",
"sequence",
"file",
"writer"
]
| [
"public",
"static",
"writer",
"create",
"writer",
"(",
"file",
"context",
"fc",
",",
"configuration",
"conf",
",",
"path",
"name",
",",
"class",
"key",
"class",
",",
"class",
"val",
"class",
",",
"compression",
"type",
"compression",
"type",
",",
"compression",
"codec",
"codec",
",",
"metadata",
"metadata",
",",
"final",
"enum",
"set",
"<",
"create",
"flag",
">",
"create",
"flag",
",",
"create",
"opts",
"opts",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"create",
"writer",
"(",
"conf",
",",
"fc",
"create",
"(",
"name",
",",
"create",
"flag",
",",
"opts",
")",
",",
"key",
"class",
",",
"val",
"class",
",",
"compression",
"type",
",",
"codec",
",",
"metadata",
")",
"own",
"stream",
"(",
")",
";",
"}"
]
|
[
"called",
"when",
"a",
"view",
"has",
"been",
"clicked"
]
| [
"void",
"on",
"value",
"change",
"(",
"dynamic",
"value",
"<",
"t",
">",
"value",
")",
";"
]
|
[
"create",
"a",
"builder",
"with",
"the",
"given",
"object",
"and",
"type",
"reference"
]
| [
"static",
"<",
"t",
">",
"builder",
"<",
"t",
">",
"from",
"object",
"(",
"t",
"t",
",",
"parameterized",
"type",
"reference",
"<",
"t",
">",
"entity",
"type",
")",
"{",
"return",
"default",
"entity",
"response",
"builder",
"from",
"object",
"(",
"t",
",",
"entity",
"type",
")",
";",
"}"
]
|
[
"@",
"t",
"c",
"description",
":",
"@",
"test",
"step",
":",
"@",
"expect",
"result",
":"
]
| [
"public",
"void",
"multiple",
"tenant",
"server",
"status",
"(",
")",
"throws",
"exception",
"{",
"assert",
"assert",
"equals",
"(",
"test",
"server",
"status",
",",
"naming",
"1",
"get",
"server",
"status",
"(",
")",
")",
";",
"assert",
"assert",
"equals",
"(",
"test",
"server",
"status",
",",
"naming",
"2",
"get",
"server",
"status",
"(",
")",
")",
";",
"}"
]
|
[
"requests",
"the",
"{",
"@",
"link",
"archived",
"execution",
"graph",
"}",
"for",
"the",
"given",
"job",
"id",
"if",
"there",
"is",
"no",
"such",
"graph",
",",
"then",
"the",
"future",
"is",
"completed",
"with",
"a",
"{",
"@",
"link",
"flink",
"job",
"not",
"found",
"exception",
"}"
]
| [
"completable",
"future",
"<",
"archived",
"execution",
"graph",
">",
"request",
"job",
"(",
"job",
"i",
"d",
"job",
"id",
",",
"@",
"rpc",
"timeout",
"time",
"timeout",
")",
";"
]
|
[
"issue",
"a",
"write",
"block",
"call",
"with",
"dummy",
"parameters",
"the",
"only",
"parameter",
"useful",
"for",
"this",
"test",
"is",
"the",
"value",
"of",
"lazy",
"persist"
]
| [
"private",
"void",
"issue",
"write",
"block",
"call",
"(",
"data",
"xceiver",
"xceiver",
",",
"boolean",
"lazy",
"persist",
")",
"throws",
"i",
"o",
"exception",
"{",
"xceiver",
"write",
"block",
"(",
"new",
"extended",
"block",
"(",
"\"",
"dummy",
"-",
"pool",
"\"",
",",
"0l",
")",
",",
"storage",
"type",
"ram",
"disk",
",",
"null",
",",
"\"",
"dummy",
"-",
"client",
"\"",
",",
"new",
"datanode",
"info",
"[",
"0",
"]",
",",
"new",
"storage",
"type",
"[",
"0",
"]",
",",
"mock",
"(",
"datanode",
"info",
"class",
")",
",",
"block",
"construction",
"stage",
"pipeline",
"setup",
"create",
",",
"0",
",",
"0",
",",
"0",
",",
"0",
",",
"data",
"checksum",
"new",
"data",
"checksum",
"(",
"data",
"checksum",
"type",
"null",
",",
"0",
")",
",",
"caching",
"strategy",
"new",
"default",
"strategy",
"(",
")",
",",
"lazy",
"persist",
",",
"false",
",",
"null",
",",
"null",
",",
"new",
"string",
"[",
"0",
"]",
")",
";",
"}"
]
|
[
"returns",
"true",
"if",
"the",
"given",
"node",
"is",
"a",
"child",
"of",
"this",
"node",
"or",
"one",
"of",
"its",
"children"
]
| [
"public",
"boolean",
"is",
"ancestor",
"(",
"g",
"tree",
"node",
"node",
")",
"{",
"g",
"tree",
"node",
"node",
"parent",
"=",
"node",
"get",
"parent",
"(",
")",
";",
"while",
"(",
"node",
"parent",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"node",
"parent",
"equals",
"(",
"this",
")",
")",
"{",
"return",
"true",
";",
"}",
"node",
"parent",
"=",
"node",
"parent",
"get",
"parent",
"(",
")",
";",
"}",
"return",
"false",
";",
"}"
]
|
[
"returns",
"the",
"root",
"file",
"for",
"this",
"file"
]
| [
"public",
"file",
"get",
"file",
"system",
"root",
"(",
")",
"{",
"return",
"resource",
"get",
"file",
"system",
"root",
"(",
")",
";",
"}"
]
|
[
"returns",
"an",
"instance",
"that",
"uses",
"{",
"@",
"code",
"source",
"}",
"as",
"a",
"reference",
"point",
"for",
"newly",
"added",
"errors"
]
| [
"public",
"errors",
"with",
"source",
"(",
"object",
"source",
")",
"{",
"return",
"source",
"=",
"=",
"source",
"provider",
"unknown",
"source",
"?",
"this",
":",
"new",
"errors",
"(",
"this",
",",
"source",
")",
";",
"}"
]
|
[
"variation",
"of",
"{",
"@",
"link",
"type",
"#",
"convert",
"}",
"that",
"supports",
"selector",
"expressions",
"for",
"configurable",
"attributes",
"(",
"i",
"e",
"\"",
"{",
"config",
"1",
":",
"'",
"value",
"1",
"of",
"orig",
"type",
"'",
",",
"config",
"2",
":",
"'",
"value",
"2",
"of",
"orig",
"type",
";",
"}",
"\"",
")",
"if",
"x",
"is",
"a",
"selector",
"expression",
",",
"returns",
"a",
"{",
"@",
"link",
"selector",
"}",
"instance",
"that",
"contains",
"key",
"-",
"mapped",
"entries",
"of",
"the",
"native",
"type",
"else",
",",
"returns",
"the",
"native",
"type",
"directly",
"the",
"caller",
"is",
"responsible",
"for",
"casting",
"the",
"returned",
"value",
"appropriately"
]
| [
"public",
"static",
"<",
"t",
">",
"object",
"selectable",
"convert",
"(",
"type",
"<",
"t",
">",
"type",
",",
"object",
"x",
",",
"object",
"what",
",",
"label",
"conversion",
"context",
"context",
")",
"throws",
"conversion",
"exception",
"{",
"if",
"(",
"x",
"instanceof",
"com",
"google",
"devtools",
"build",
"lib",
"packages",
"selector",
"list",
")",
"{",
"return",
"new",
"selector",
"list",
"<",
"t",
">",
"(",
"(",
"(",
"com",
"google",
"devtools",
"build",
"lib",
"packages",
"selector",
"list",
")",
"x",
")",
"get",
"elements",
"(",
")",
",",
"what",
",",
"context",
",",
"type",
")",
";",
"}",
"else",
"{",
"return",
"type",
"convert",
"(",
"x",
",",
"what",
",",
"context",
")",
";",
"}",
"}"
]
|
[
"adds",
"additional",
"command",
"line",
"arguments",
"to",
"be",
"used",
"when",
"starting",
"opera",
"for",
"example",
":",
"<",
"code",
">",
"options",
"set",
"arguments",
"(",
"\"",
"load",
"-",
"extension",
"=",
"pathtounpacked",
"extension",
"\"",
",",
"\"",
"allow",
"-",
"outdated",
"-",
"plugins",
"\"",
")",
";",
"<",
"code",
">",
"each",
"argument",
"may",
"contain",
"an",
"option",
"\"",
"-",
"-",
"\"",
"prefix",
":",
"\"",
"-",
"-",
"foo",
"\"",
"or",
"\"",
"foo",
"\"",
"arguments",
"with",
"an",
"associated",
"value",
"should",
"be",
"delimited",
"with",
"an",
"\"",
"=",
"\"",
":",
"\"",
"foo",
"=",
"bar",
"\""
]
| [
"public",
"opera",
"options",
"add",
"arguments",
"(",
"list",
"<",
"string",
">",
"arguments",
")",
"{",
"args",
"add",
"all",
"(",
"arguments",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"find",
"unaligned",
"structure",
"bitfield",
"component",
"at",
"or",
"after",
"specified",
"component",
"which",
"matches",
"this",
"info",
"'",
"s",
"bitfield",
"data"
]
| [
"data",
"type",
"component",
"find",
"structure",
"bit",
"field",
"component",
"at",
"or",
"after",
"(",
"structure",
"struct",
",",
"data",
"type",
"component",
"dtc",
")",
"{",
"if",
"(",
"bit",
"offset",
"<",
"0",
")",
"{",
"return",
"null",
";",
"}",
"int",
"max",
"ordinal",
"=",
"struct",
"get",
"num",
"components",
"(",
")",
";",
"while",
"(",
"dtc",
"!",
"=",
"null",
"&",
"&",
"dtc",
"get",
"offset",
"(",
")",
"<",
"=",
"index",
")",
"{",
"if",
"(",
"dtc",
"is",
"bit",
"field",
"component",
"(",
")",
")",
"{",
"bit",
"field",
"data",
"type",
"bf",
"dt",
"=",
"(",
"bit",
"field",
"data",
"type",
")",
"dtc",
"get",
"data",
"type",
"(",
")",
";",
"if",
"(",
"bit",
"size",
"=",
"=",
"bf",
"dt",
"get",
"declared",
"bit",
"size",
"(",
")",
"&",
"&",
"bit",
"offset",
"=",
"=",
"bf",
"dt",
"get",
"bit",
"offset",
"(",
")",
")",
"{",
"return",
"dtc",
";",
"}",
"}",
"int",
"next",
"ordinal",
"=",
"dtc",
"get",
"ordinal",
"(",
")",
"+",
"1",
";",
"if",
"(",
"next",
"ordinal",
">",
"max",
"ordinal",
")",
"{",
"break",
";",
"}",
"struct",
"get",
"component",
"(",
"next",
"ordinal",
")",
";",
"}",
"return",
"null",
";",
"}"
]
|
[
"{",
"@",
"inherit",
"doc",
"}",
"the",
"default",
"implementation",
"returns",
"the",
"result",
"of",
"calling",
"{",
"@",
"link",
"#",
"visit",
"children",
"}",
"on",
"{",
"@",
"code",
"ctx",
"}"
]
| [
"@",
"override",
"public",
"t",
"visit",
"cast",
"(",
"sql",
"base",
"parser",
"cast",
"context",
"ctx",
")",
"{",
"return",
"visit",
"children",
"(",
"ctx",
")",
";",
"}"
]
|
[
"attempt",
"to",
"partially",
"resolve",
"group",
"names"
]
| [
"private",
"set",
"<",
"string",
">",
"resolve",
"partial",
"group",
"names",
"(",
"string",
"user",
"name",
",",
"string",
"err",
"message",
",",
"string",
"group",
"names",
")",
"throws",
"partial",
"group",
"name",
"exception",
"{",
"/",
"/",
"exception",
"may",
"indicate",
"that",
"some",
"group",
"names",
"are",
"not",
"resolvable",
"/",
"/",
"shell",
"-",
"based",
"implementation",
"should",
"tolerate",
"unresolvable",
"groups",
"names",
",",
"/",
"/",
"and",
"return",
"resolvable",
"ones",
",",
"similar",
"to",
"what",
"jni",
"-",
"based",
"implementation",
"/",
"/",
"does",
"if",
"(",
"shell",
"windows",
")",
"{",
"throw",
"new",
"partial",
"group",
"name",
"exception",
"(",
"\"",
"does",
"not",
"support",
"partial",
"group",
"\"",
"+",
"\"",
"name",
"resolution",
"on",
"windows",
"\"",
"+",
"err",
"message",
")",
";",
"}",
"if",
"(",
"group",
"names",
"is",
"empty",
"(",
")",
")",
"{",
"throw",
"new",
"partial",
"group",
"name",
"exception",
"(",
"\"",
"the",
"user",
"name",
"'",
"\"",
"+",
"user",
"name",
"+",
"\"",
"'",
"is",
"not",
"found",
"\"",
"+",
"err",
"message",
")",
";",
"}",
"else",
"{",
"log",
"warn",
"(",
"\"",
"some",
"group",
"names",
"for",
"'",
"{",
"}",
"'",
"are",
"not",
"resolvable",
"{",
"}",
"\"",
",",
"user",
"name",
",",
"err",
"message",
")",
";",
"/",
"/",
"attempt",
"to",
"partially",
"resolve",
"group",
"names",
"shell",
"command",
"executor",
"partial",
"resolver",
"=",
"create",
"group",
"i",
"d",
"executor",
"(",
"user",
"name",
")",
";",
"try",
"{",
"partial",
"resolver",
"execute",
"(",
")",
";",
"return",
"parse",
"partial",
"group",
"names",
"(",
"group",
"names",
",",
"partial",
"resolver",
"get",
"output",
"(",
")",
")",
";",
"}",
"catch",
"(",
"exit",
"code",
"exception",
"ece",
")",
"{",
"/",
"/",
"if",
"exception",
"is",
"thrown",
"trying",
"to",
"get",
"group",
"id",
"list",
",",
"/",
"/",
"something",
"is",
"terribly",
"wrong",
",",
"so",
"give",
"up",
"throw",
"new",
"partial",
"group",
"name",
"exception",
"(",
"\"",
"failed",
"to",
"get",
"group",
"id",
"list",
"for",
"user",
"'",
"\"",
"+",
"user",
"name",
"+",
"\"",
"'",
"\"",
",",
"ece",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ioe",
")",
"{",
"string",
"message",
"=",
"\"",
"can",
"'",
"t",
"execute",
"the",
"shell",
"command",
"to",
"\"",
"+",
"\"",
"get",
"the",
"list",
"of",
"group",
"id",
"for",
"user",
"'",
"\"",
"+",
"user",
"name",
"+",
"\"",
"'",
"\"",
";",
"if",
"(",
"partial",
"resolver",
"is",
"timed",
"out",
"(",
")",
")",
"{",
"message",
"+",
"=",
"\"",
"because",
"of",
"the",
"command",
"taking",
"longer",
"than",
"\"",
"+",
"\"",
"the",
"configured",
"timeout",
":",
"\"",
"+",
"timeout",
"+",
"\"",
"seconds",
"\"",
";",
"}",
"throw",
"new",
"partial",
"group",
"name",
"exception",
"(",
"message",
",",
"ioe",
")",
";",
"}",
"}",
"}"
]
|
[
"merge",
"`",
"other",
"`",
"cuckoo",
"filter",
"into",
"this",
"cuckoo",
"after",
"merging",
",",
"this",
"filter",
"'",
"s",
"state",
"will",
"be",
"the",
"union",
"of",
"the",
"two",
"during",
"the",
"merging",
"process",
",",
"the",
"internal",
"set",
"may",
"be",
"upgraded",
"to",
"a",
"cuckoo",
"if",
"it",
"goes",
"over",
"threshold"
]
| [
"public",
"void",
"merge",
"(",
"set",
"backed",
"scaling",
"cuckoo",
"filter",
"other",
")",
"{",
"/",
"/",
"some",
"basic",
"sanity",
"checks",
"to",
"make",
"sure",
"we",
"can",
"merge",
"if",
"(",
"this",
"threshold",
"!",
"=",
"other",
"threshold",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"cannot",
"merge",
"other",
"cuckoo",
"filter",
"because",
"thresholds",
"do",
"not",
"match",
":",
"[",
"\"",
"+",
"this",
"threshold",
"+",
"\"",
"]",
"vs",
"[",
"\"",
"+",
"other",
"threshold",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"if",
"(",
"this",
"capacity",
"!",
"=",
"other",
"capacity",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"cannot",
"merge",
"other",
"cuckoo",
"filter",
"because",
"capacities",
"do",
"not",
"match",
":",
"[",
"\"",
"+",
"this",
"capacity",
"+",
"\"",
"]",
"vs",
"[",
"\"",
"+",
"other",
"capacity",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"if",
"(",
"this",
"fpp",
"!",
"=",
"other",
"fpp",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"cannot",
"merge",
"other",
"cuckoo",
"filter",
"because",
"precisions",
"do",
"not",
"match",
":",
"[",
"\"",
"+",
"this",
"fpp",
"+",
"\"",
"]",
"vs",
"[",
"\"",
"+",
"other",
"fpp",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"if",
"(",
"is",
"set",
"mode",
"&",
"&",
"other",
"is",
"set",
"mode",
")",
"{",
"/",
"/",
"both",
"in",
"sets",
",",
"merge",
"collections",
"then",
"see",
"if",
"we",
"need",
"to",
"convert",
"to",
"cuckoo",
"hashes",
"add",
"all",
"(",
"other",
"hashes",
")",
";",
"maybe",
"convert",
"(",
")",
";",
"}",
"else",
"if",
"(",
"is",
"set",
"mode",
"&",
"&",
"other",
"is",
"set",
"mode",
"=",
"=",
"false",
")",
"{",
"/",
"/",
"other",
"is",
"in",
"cuckoo",
"mode",
",",
"so",
"we",
"convert",
"our",
"set",
"to",
"a",
"cuckoo",
",",
"then",
"/",
"/",
"call",
"the",
"merge",
"function",
"again",
"since",
"both",
"are",
"now",
"in",
"set",
"-",
"mode",
"/",
"/",
"this",
"will",
"fall",
"through",
"to",
"the",
"last",
"conditional",
"and",
"do",
"a",
"cuckoo",
"-",
"cuckoo",
"merge",
"convert",
"(",
")",
";",
"merge",
"(",
"other",
")",
";",
"}",
"else",
"if",
"(",
"is",
"set",
"mode",
"=",
"=",
"false",
"&",
"&",
"other",
"is",
"set",
"mode",
")",
"{",
"/",
"/",
"rather",
"than",
"converting",
"the",
"other",
"to",
"a",
"cuckoo",
"first",
",",
"we",
"can",
"just",
"/",
"/",
"replay",
"the",
"values",
"directly",
"into",
"our",
"filter",
"other",
"hashes",
"for",
"each",
"(",
"this",
":",
":",
"add",
")",
";",
"}",
"else",
"{",
"/",
"/",
"both",
"are",
"in",
"cuckoo",
"mode",
",",
"merge",
"raw",
"fingerprints",
"cuckoo",
"filter",
"current",
"filter",
"=",
"filters",
"get",
"(",
"filters",
"size",
"(",
")",
"-",
"1",
")",
";",
"for",
"(",
"cuckoo",
"filter",
"other",
"filter",
":",
"other",
"filters",
")",
"{",
"/",
"/",
"the",
"iterator",
"returns",
"an",
"array",
"of",
"longs",
"corresponding",
"to",
"the",
"/",
"/",
"fingerprints",
"for",
"buckets",
"at",
"the",
"current",
"position",
"iterator",
"<",
"long",
"[",
"]",
">",
"iter",
"=",
"other",
"filter",
"get",
"buckets",
"(",
")",
";",
"int",
"bucket",
"=",
"0",
";",
"while",
"(",
"iter",
"has",
"next",
"(",
")",
")",
"{",
"long",
"[",
"]",
"fingerprints",
"=",
"iter",
"next",
"(",
")",
";",
"/",
"/",
"we",
"check",
"to",
"see",
"if",
"the",
"fingerprint",
"is",
"present",
"in",
"any",
"of",
"the",
"existing",
"filters",
"/",
"/",
"(",
"in",
"the",
"same",
"bucket",
"/",
"alternate",
"bucket",
")",
",",
"or",
"if",
"the",
"fingerprint",
"is",
"empty",
"in",
"these",
"cases",
"/",
"/",
"we",
"can",
"skip",
"the",
"fingerprint",
"for",
"(",
"long",
"fingerprint",
":",
"fingerprints",
")",
"{",
"if",
"(",
"fingerprint",
"=",
"=",
"cuckoo",
"filter",
"empty",
"|",
"|",
"might",
"contain",
"fingerprint",
"(",
"bucket",
",",
"(",
"int",
")",
"fingerprint",
")",
")",
"{",
"continue",
";",
"}",
"/",
"/",
"try",
"to",
"insert",
"into",
"the",
"last",
"filter",
"in",
"our",
"list",
"if",
"(",
"current",
"filter",
"merge",
"fingerprint",
"(",
"bucket",
",",
"(",
"int",
")",
"fingerprint",
")",
"=",
"=",
"false",
")",
"{",
"/",
"/",
"if",
"we",
"failed",
",",
"the",
"filter",
"is",
"now",
"saturated",
"and",
"we",
"need",
"to",
"create",
"a",
"new",
"one",
"cuckoo",
"filter",
"t",
"=",
"new",
"cuckoo",
"filter",
"(",
"capacity",
",",
"fpp",
",",
"rng",
")",
";",
"filters",
"add",
"(",
"t",
")",
";",
"breaker",
"accept",
"(",
"t",
"get",
"size",
"in",
"bytes",
"(",
")",
")",
";",
"/",
"/",
"make",
"sure",
"we",
"account",
"for",
"the",
"new",
"filter",
"current",
"filter",
"=",
"filters",
"get",
"(",
"filters",
"size",
"(",
")",
"-",
"1",
")",
";",
"}",
"}",
"bucket",
"+",
"=",
"1",
";",
"}",
"}",
"}",
"}"
]
|
[
"extract",
"the",
"sub",
"-",
"region",
"of",
"the",
"specified",
"buffer"
]
| [
"protected",
"byte",
"buf",
"extract",
"frame",
"(",
"channel",
"handler",
"context",
"ctx",
",",
"byte",
"buf",
"buffer",
",",
"int",
"index",
",",
"int",
"length",
")",
"{",
"return",
"buffer",
"retained",
"slice",
"(",
"index",
",",
"length",
")",
";",
"}"
]
|
[
"returns",
"the",
"index",
"for",
"the",
"given",
"address",
"if",
"the",
"address",
"is",
"not",
"mapped",
",",
"the",
"result",
"is",
"defined",
"as",
"follows",
":",
"if",
"the",
"address",
"is",
"less",
"than",
"the",
"smallest",
"address",
"in",
"the",
"map",
",",
"then",
"null",
"is",
"returned",
"if",
"the",
"address",
"is",
"greater",
"the",
"the",
"largest",
"address",
"in",
"the",
"map",
",",
"then",
"a",
"value",
"one",
"bigger",
"than",
"the",
"index",
"of",
"the",
"largest",
"address",
"in",
"the",
"map",
"if",
"the",
"address",
"is",
"in",
"a",
"\"",
"gap",
"\"",
",",
"then",
"the",
"index",
"of",
"the",
"next",
"largest",
"address",
"that",
"is",
"in",
"the",
"map",
"is",
"returned"
]
| [
"public",
"big",
"integer",
"get",
"index",
"at",
"or",
"after",
"(",
"address",
"addr",
")",
"{",
"int",
"range",
"index",
"=",
"arrays",
"binary",
"search",
"(",
"address",
"list",
",",
"addr",
")",
";",
"if",
"(",
"range",
"index",
">",
"=",
"0",
")",
"{",
"return",
"index",
"list",
"[",
"range",
"index",
"]",
";",
"}",
"range",
"index",
"=",
"-",
"range",
"index",
"-",
"2",
";",
"if",
"(",
"range",
"index",
"<",
"0",
")",
"{",
"return",
"big",
"integer",
"zero",
";",
"}",
"if",
"(",
"!",
"(",
"addr",
"get",
"address",
"space",
"(",
")",
"equals",
"(",
"address",
"list",
"[",
"range",
"index",
"]",
"get",
"address",
"space",
"(",
")",
")",
")",
")",
"{",
"return",
"index",
"list",
"[",
"range",
"index",
"+",
"1",
"]",
";",
"}",
"big",
"integer",
"offset",
"=",
"addr",
"get",
"offset",
"as",
"big",
"integer",
"(",
")",
"subtract",
"(",
"address",
"list",
"[",
"range",
"index",
"]",
"get",
"offset",
"as",
"big",
"integer",
"(",
")",
")",
";",
"big",
"integer",
"index",
"=",
"index",
"list",
"[",
"range",
"index",
"]",
"add",
"(",
"offset",
")",
";",
"if",
"(",
"index",
"compare",
"to",
"(",
"index",
"list",
"[",
"range",
"index",
"+",
"1",
"]",
")",
">",
"=",
"0",
")",
"{",
"return",
"index",
"list",
"[",
"range",
"index",
"+",
"1",
"]",
";",
"}",
"return",
"index",
";",
"}"
]
|
[
"applies",
"an",
"acl",
"(",
"both",
"access",
"and",
"default",
")",
"to",
"the",
"given",
"path"
]
| [
"private",
"static",
"void",
"apply",
"acl",
"(",
"path",
"p",
")",
"throws",
"i",
"o",
"exception",
"{",
"hdfs",
"modify",
"acl",
"entries",
"(",
"p",
",",
"arrays",
"as",
"list",
"(",
"acl",
"entry",
"(",
"access",
",",
"user",
",",
"user",
"2",
"get",
"short",
"user",
"name",
"(",
")",
",",
"all",
")",
",",
"acl",
"entry",
"(",
"default",
",",
"user",
",",
"user",
"2",
"get",
"short",
"user",
"name",
"(",
")",
",",
"all",
")",
")",
")",
";",
"}"
]
|
[
"sets",
"the",
"is",
"tabs",
"shadow",
"of",
"this",
"m",
"t",
"config",
"object"
]
| [
"public",
"void",
"set",
"is",
"tabs",
"shadow",
"(",
"final",
"boolean",
"is",
"tabs",
"shadow",
")",
"{",
"this",
"is",
"tabs",
"shadow",
"=",
"is",
"tabs",
"shadow",
";",
"}"
]
|
[
"creates",
"a",
"library",
"to",
"link",
"with",
"the",
"specified",
"object",
"files"
]
| [
"public",
"static",
"library",
"to",
"link",
"new",
"input",
"library",
"(",
"artifact",
"library",
",",
"artifact",
"category",
"category",
",",
"string",
"library",
"identifier",
",",
"iterable",
"<",
"artifact",
">",
"object",
"files",
",",
"lto",
"compilation",
"context",
"lto",
"compilation",
"context",
",",
"immutable",
"map",
"<",
"artifact",
",",
"lto",
"backend",
"artifacts",
">",
"shared",
"non",
"lto",
"backends",
",",
"boolean",
"must",
"keep",
"debug",
",",
"boolean",
"disable",
"whole",
"archive",
")",
"{",
"return",
"new",
"compound",
"library",
"to",
"link",
"(",
"library",
",",
"category",
",",
"library",
"identifier",
",",
"object",
"files",
",",
"lto",
"compilation",
"context",
",",
"shared",
"non",
"lto",
"backends",
",",
"/",
"*",
"allow",
"archive",
"type",
"in",
"alwayslink",
"=",
"*",
"/",
"true",
",",
"must",
"keep",
"debug",
",",
"disable",
"whole",
"archive",
")",
";",
"}"
]
|
[
"tests",
"that",
"broadcasted",
"records",
"'",
"buffers",
"are",
"independent",
"(",
"in",
"their",
"(",
"reader",
")",
"indices",
")",
"once",
"they",
"are",
"put",
"into",
"the",
"queue",
"for",
"netty",
"when",
"broadcasting",
"events",
"to",
"multiple",
"channels"
]
| [
"public",
"void",
"test",
"broadcast",
"emit",
"buffer",
"independence",
"(",
")",
"throws",
"exception",
"{",
"verify",
"broadcast",
"buffer",
"or",
"event",
"independence",
"(",
"false",
")",
";",
"}"
]
|
[
"copies",
"a",
"collection",
"of",
"{",
"@",
"code",
"boolean",
"}",
"instances",
"into",
"a",
"new",
"array",
"of",
"primitive",
"{",
"@",
"code",
"boolean",
"}",
"values",
"elements",
"are",
"copied",
"from",
"the",
"argument",
"collection",
"as",
"if",
"by",
"{",
"@",
"code",
"collection",
"to",
"array",
"(",
")",
"}",
"calling",
"this",
"method",
"is",
"as",
"thread",
"-",
"safe",
"as",
"calling",
"that",
"method",
"<",
"b",
">",
"note",
":",
"<",
"b",
">",
"consider",
"representing",
"the",
"collection",
"as",
"a",
"{",
"@",
"link",
"java",
"util",
"bit",
"set",
"}",
"instead"
]
| [
"public",
"static",
"boolean",
"[",
"]",
"to",
"array",
"(",
"collection",
"<",
"boolean",
">",
"collection",
")",
"{",
"if",
"(",
"collection",
"instanceof",
"boolean",
"array",
"as",
"list",
")",
"{",
"return",
"(",
"(",
"boolean",
"array",
"as",
"list",
")",
"collection",
")",
"to",
"boolean",
"array",
"(",
")",
";",
"}",
"object",
"[",
"]",
"boxed",
"array",
"=",
"collection",
"to",
"array",
"(",
")",
";",
"int",
"len",
"=",
"boxed",
"array",
"length",
";",
"boolean",
"[",
"]",
"array",
"=",
"new",
"boolean",
"[",
"len",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"len",
";",
"i",
"+",
"+",
")",
"{",
"/",
"/",
"check",
"not",
"null",
"for",
"gwt",
"(",
"do",
"not",
"optimize",
")",
"array",
"[",
"i",
"]",
"=",
"(",
"boolean",
")",
"check",
"not",
"null",
"(",
"boxed",
"array",
"[",
"i",
"]",
")",
";",
"}",
"return",
"array",
";",
"}"
]
|
[
"add",
"a",
"block",
"to",
"the",
"block",
"list"
]
| [
"void",
"add",
"block",
"(",
"block",
"info",
"newblock",
")",
"{",
"preconditions",
"check",
"argument",
"(",
"newblock",
"is",
"striped",
"(",
")",
"=",
"=",
"this",
"is",
"striped",
"(",
")",
")",
";",
"if",
"(",
"this",
"blocks",
"length",
"=",
"=",
"0",
")",
"{",
"this",
"set",
"blocks",
"(",
"new",
"block",
"info",
"[",
"]",
"{",
"newblock",
"}",
")",
";",
"}",
"else",
"{",
"int",
"size",
"=",
"this",
"blocks",
"length",
";",
"block",
"info",
"[",
"]",
"newlist",
"=",
"new",
"block",
"info",
"[",
"size",
"+",
"1",
"]",
";",
"system",
"arraycopy",
"(",
"this",
"blocks",
",",
"0",
",",
"newlist",
",",
"0",
",",
"size",
")",
";",
"newlist",
"[",
"size",
"]",
"=",
"newblock",
";",
"this",
"set",
"blocks",
"(",
"newlist",
")",
";",
"}",
"}"
]
|
[
"whether",
"this",
"{",
"@",
"link",
"component",
"lifecycle",
"}",
"mounts",
"views",
"that",
"contain",
"component",
"-",
"based",
"content",
"that",
"can",
"be",
"incrementally",
"mounted",
"e",
"g",
"if",
"the",
"mounted",
"view",
"has",
"a",
"litho",
"view",
"with",
"incremental",
"mount",
"enabled"
]
| [
"protected",
"boolean",
"has",
"child",
"litho",
"views",
"(",
")",
"{",
"return",
"false",
";",
"}"
]
|
[
"runs",
"the",
"registered",
"health",
"checks",
"matching",
"the",
"filter",
"and",
"returns",
"a",
"map",
"of",
"the",
"results"
]
| [
"public",
"sorted",
"map",
"<",
"string",
",",
"health",
"check",
"result",
">",
"run",
"health",
"checks",
"(",
"health",
"check",
"filter",
"filter",
")",
"{",
"final",
"sorted",
"map",
"<",
"string",
",",
"health",
"check",
"result",
">",
"results",
"=",
"new",
"tree",
"map",
"<",
">",
"(",
")",
";",
"for",
"(",
"map",
"entry",
"<",
"string",
",",
"health",
"check",
">",
"entry",
":",
"health",
"checks",
"entry",
"set",
"(",
")",
")",
"{",
"final",
"string",
"name",
"=",
"entry",
"get",
"key",
"(",
")",
";",
"final",
"health",
"check",
"health",
"check",
"=",
"entry",
"get",
"value",
"(",
")",
";",
"if",
"(",
"filter",
"matches",
"(",
"name",
",",
"health",
"check",
")",
")",
"{",
"final",
"result",
"result",
"=",
"entry",
"get",
"value",
"(",
")",
"execute",
"(",
")",
";",
"results",
"put",
"(",
"entry",
"get",
"key",
"(",
")",
",",
"result",
")",
";",
"}",
"}",
"return",
"collections",
"unmodifiable",
"sorted",
"map",
"(",
"results",
")",
";",
"}"
]
|
[
"{",
"@",
"inherit",
"doc",
"}"
]
| [
"public",
"string",
"to",
"string",
"(",
")",
"{",
"return",
"descriptor",
";",
"}"
]
|
[
"returns",
"the",
"count",
"of",
"applications",
"in",
"enabled",
"{",
"@",
"link",
"batch",
"group",
"}",
"s",
"in",
"other",
"words",
",",
"the",
"number",
"of",
"objects",
"that",
"would",
"be",
"imported",
"during",
"this",
"batch"
]
| [
"public",
"int",
"get",
"enabled",
"count",
"(",
")",
"{",
"int",
"count",
"=",
"0",
";",
"for",
"(",
"batch",
"group",
"batch",
"group",
":",
"groups",
"by",
"criteria",
"values",
"(",
")",
")",
"{",
"if",
"(",
"batch",
"group",
"is",
"enabled",
"(",
")",
")",
"{",
"count",
"+",
"=",
"batch",
"group",
"get",
"batch",
"load",
"config",
"(",
")",
"size",
"(",
")",
";",
"}",
"}",
"return",
"count",
";",
"}"
]
|
[
"coerce",
"a",
"number",
"value",
"into",
"the",
"required",
"target",
"class",
",",
"if",
"necessary"
]
| [
"public",
"void",
"set",
"value",
"(",
"@",
"nullable",
"object",
"value",
")",
"{",
"if",
"(",
"value",
"instanceof",
"number",
")",
"{",
"super",
"set",
"value",
"(",
"number",
"utils",
"convert",
"number",
"to",
"target",
"class",
"(",
"(",
"number",
")",
"value",
",",
"this",
"number",
"class",
")",
")",
";",
"}",
"else",
"{",
"super",
"set",
"value",
"(",
"value",
")",
";",
"}",
"}"
]
|
[
"loosely",
"defined",
"as",
"a",
"character",
"that",
"we",
"would",
"expected",
"to",
"be",
"an",
"normal",
"ascii",
"content",
"meant",
"for",
"consumption",
"by",
"a",
"human",
"also",
",",
"provided",
"allows",
"chars",
"will",
"pass",
"the",
"test"
]
| [
"public",
"static",
"boolean",
"is",
"word",
"char",
"(",
"char",
"c",
",",
"char",
"[",
"]",
"chars",
"to",
"allow",
")",
"{",
"if",
"(",
"chars",
"to",
"allow",
"!",
"=",
"null",
")",
"{",
"for",
"(",
"char",
"element",
":",
"chars",
"to",
"allow",
")",
"{",
"if",
"(",
"c",
"=",
"=",
"element",
")",
"{",
"return",
"true",
";",
"}",
"}",
"}",
"/",
"/",
"the",
"code",
",",
"before",
"refactoring",
",",
"was",
"using",
"the",
"'",
"c",
"language",
"'",
"check",
"for",
"'",
"wordness",
"'",
"keep",
"/",
"/",
"that",
"for",
"now",
",",
"change",
"it",
"if",
"you",
"like",
"return",
"is",
"valid",
"c",
"language",
"char",
"(",
"c",
")",
";",
"}"
]
|
[
"template",
"method",
"for",
"handling",
"{",
"@",
"code",
"d",
"o",
"m",
"result",
"}",
"s",
"this",
"implementation",
"delegates",
"to",
"{",
"@",
"code",
"marshal",
"dom",
"node",
"}"
]
| [
"protected",
"void",
"marshal",
"dom",
"result",
"(",
"object",
"graph",
",",
"d",
"o",
"m",
"result",
"dom",
"result",
")",
"throws",
"xml",
"mapping",
"exception",
"{",
"if",
"(",
"dom",
"result",
"get",
"node",
"(",
")",
"=",
"=",
"null",
")",
"{",
"dom",
"result",
"set",
"node",
"(",
"build",
"document",
"(",
")",
")",
";",
"}",
"marshal",
"dom",
"node",
"(",
"graph",
",",
"dom",
"result",
"get",
"node",
"(",
")",
")",
";",
"}"
]
|
[
"returns",
"whether",
"the",
"use",
"of",
"local",
"thumbnails",
"for",
"previews",
"is",
"enabled"
]
| [
"public",
"boolean",
"is",
"local",
"thumbnail",
"previews",
"enabled",
"(",
")",
"{",
"return",
"m",
"local",
"thumbnail",
"previews",
"enabled",
";",
"}"
]
|
[
"register",
"a",
"routine",
"for",
"debug",
"drawing",
"the",
"debug",
"draw",
"functions",
"are",
"called",
"inside",
"with",
"world",
"draw",
"debug",
"data",
"method",
"the",
"debug",
"draw",
"object",
"is",
"owned",
"by",
"you",
"and",
"must",
"remain",
"in",
"scope"
]
| [
"public",
"void",
"set",
"debug",
"draw",
"(",
"debug",
"draw",
"debug",
"draw",
")",
"{",
"m",
"debug",
"draw",
"=",
"debug",
"draw",
";",
"}"
]
|
[
"sets",
"the",
"serializer",
"to",
"use",
"when",
"the",
"type",
"being",
"deserialized",
"is",
"not",
"known",
"(",
"null",
")"
]
| [
"public",
"void",
"set",
"default",
"serializer",
"(",
"serializer",
"default",
"serializer",
")",
"{",
"this",
"default",
"serializer",
"=",
"default",
"serializer",
";",
"}"
]
|
[
"returns",
"whether",
"they",
"key",
"matches",
"at",
"the",
"specified",
"depth"
]
| [
"public",
"boolean",
"matches",
"(",
"string",
"key",
",",
"int",
"depth",
")",
"{",
"if",
"(",
"is",
"container",
"(",
"key",
")",
")",
"{",
"/",
"/",
"this",
"is",
"an",
"artificial",
"layer",
"we",
"programatically",
"create",
"return",
"true",
";",
"}",
"if",
"(",
"depth",
">",
"=",
"keys",
"size",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"keys",
"get",
"(",
"depth",
")",
"equals",
"(",
"key",
")",
"|",
"|",
"keys",
"get",
"(",
"depth",
")",
"equals",
"(",
"\"",
"*",
"*",
"\"",
")",
"|",
"|",
"keys",
"get",
"(",
"depth",
")",
"equals",
"(",
"\"",
"*",
"\"",
")",
")",
"{",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}"
]
|
[
"change",
"the",
"name",
"of",
"a",
"table",
"and",
"its",
"associated",
"indexes"
]
| [
"void",
"change",
"table",
"name",
"(",
"string",
"old",
"name",
",",
"string",
"new",
"name",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"table",
"records",
"length",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"old",
"name",
"equals",
"(",
"table",
"records",
"[",
"i",
"]",
"get",
"name",
"(",
")",
")",
")",
"{",
"table",
"records",
"[",
"i",
"]",
"set",
"name",
"(",
"new",
"name",
")",
";",
"}",
"}",
"}"
]
|
[
"returns",
"the",
"parent",
"of",
"a",
"path",
",",
"i",
"e",
",",
"everything",
"that",
"precedes",
"the",
"last",
"separator",
"or",
"<",
"code",
">",
"null",
"<",
"code",
">",
"if",
"at",
"root"
]
| [
"public",
"path",
"get",
"parent",
"(",
")",
"{",
"final",
"string",
"path",
"=",
"uri",
"get",
"path",
"(",
")",
";",
"final",
"int",
"last",
"slash",
"=",
"path",
"last",
"index",
"of",
"(",
"'",
"/",
"'",
")",
";",
"final",
"int",
"start",
"=",
"has",
"windows",
"drive",
"(",
"path",
",",
"true",
")",
"?",
"3",
":",
"0",
";",
"if",
"(",
"(",
"path",
"length",
"(",
")",
"=",
"=",
"start",
")",
"|",
"|",
"/",
"/",
"empty",
"path",
"(",
"last",
"slash",
"=",
"=",
"start",
"&",
"&",
"path",
"length",
"(",
")",
"=",
"=",
"start",
"+",
"1",
")",
")",
"{",
"/",
"/",
"at",
"root",
"return",
"null",
";",
"}",
"string",
"parent",
";",
"if",
"(",
"last",
"slash",
"=",
"=",
"-",
"1",
")",
"{",
"parent",
"=",
"cur",
"dir",
";",
"}",
"else",
"{",
"final",
"int",
"end",
"=",
"has",
"windows",
"drive",
"(",
"path",
",",
"true",
")",
"?",
"3",
":",
"0",
";",
"parent",
"=",
"path",
"substring",
"(",
"0",
",",
"last",
"slash",
"=",
"=",
"end",
"?",
"end",
"+",
"1",
":",
"last",
"slash",
")",
";",
"}",
"return",
"new",
"path",
"(",
"uri",
"get",
"scheme",
"(",
")",
",",
"uri",
"get",
"authority",
"(",
")",
",",
"parent",
")",
";",
"}"
]
|
[
"subclasses",
"must",
"implement",
"this",
"method",
"to",
"resolve",
"a",
"message",
"returns",
"a",
"message",
"format",
"instance",
"rather",
"than",
"a",
"message",
"string",
",",
"to",
"allow",
"for",
"appropriate",
"caching",
"of",
"message",
"formats",
"in",
"subclasses",
"<",
"b",
">",
"subclasses",
"are",
"encouraged",
"to",
"provide",
"optimized",
"resolution",
"for",
"messages",
"without",
"arguments",
",",
"not",
"involving",
"message",
"format",
"<",
"b",
">",
"see",
"the",
"{",
"@",
"link",
"#",
"resolve",
"code",
"without",
"arguments",
"}",
"javadoc",
"for",
"details"
]
| [
"protected",
"abstract",
"message",
"format",
"resolve",
"code",
"(",
"string",
"code",
",",
"locale",
"locale",
")",
";"
]
|
[
"receive",
"message",
"from",
"queue"
]
| [
"public",
"message",
"receive",
"message",
"(",
")",
"{",
"if",
"(",
"message",
"priority",
"message",
"queue",
"is",
"empty",
"(",
")",
")",
"{",
"return",
"null",
";",
"}",
"return",
"message",
"priority",
"message",
"queue",
"remove",
"(",
")",
";",
"}"
]
|
[
"creates",
"a",
"change",
"of",
"type",
"move",
"as",
"a",
"result",
"of",
"this",
"change",
"item",
"at",
"from",
"index",
"in",
"the",
"context",
"of",
"the",
"{",
"@",
"link",
"diff",
"section",
"spec",
"}",
"creating",
"this",
"change",
"will",
"be",
"moved",
"to",
"to",
"index"
]
| [
"static",
"change",
"move",
"(",
"int",
"from",
"index",
",",
"int",
"to",
"index",
",",
"@",
"nullable",
"object",
"data",
")",
"{",
"return",
"acquire",
"move",
"change",
"(",
"from",
"index",
",",
"to",
"index",
",",
"data",
")",
";",
"}"
]
|
[
"bag",
"of",
"stuff",
"to",
"allow",
"plugins",
"to",
"store",
"state",
"for",
"the",
"duration",
"of",
"a",
"build",
"without",
"persisting",
"it"
]
| [
"public",
"@",
"non",
"null",
"map",
"<",
"object",
",",
"object",
">",
"get",
"attributes",
"(",
")",
"{",
"return",
"attributes",
";",
"}"
]
|
[
"returns",
"the",
"name",
"of",
"the",
"parameter",
"the",
"name",
"must",
"be",
"unique",
"in",
"the",
"stage",
"the",
"param",
"info",
"belongs",
"to"
]
| [
"public",
"string",
"get",
"name",
"(",
")",
"{",
"return",
"name",
";",
"}"
]
|
[
"adds",
"an",
"asymmetric",
"break",
"between",
"a",
"master",
"and",
"one",
"of",
"the",
"nodes",
"and",
"makes",
"sure",
"that",
"the",
"node",
"is",
"removed",
"form",
"the",
"cluster",
",",
"that",
"the",
"node",
"start",
"pinging",
"and",
"that",
"the",
"cluster",
"reforms",
"when",
"healed"
]
| [
"public",
"void",
"test",
"node",
"not",
"reachable",
"from",
"master",
"(",
")",
"throws",
"exception",
"{",
"start",
"cluster",
"(",
"3",
")",
";",
"string",
"master",
"node",
"=",
"internal",
"cluster",
"(",
")",
"get",
"master",
"name",
"(",
")",
";",
"string",
"non",
"master",
"node",
"=",
"null",
";",
"while",
"(",
"non",
"master",
"node",
"=",
"=",
"null",
")",
"{",
"non",
"master",
"node",
"=",
"random",
"from",
"(",
"internal",
"cluster",
"(",
")",
"get",
"node",
"names",
"(",
")",
")",
";",
"if",
"(",
"non",
"master",
"node",
"equals",
"(",
"master",
"node",
")",
")",
"{",
"non",
"master",
"node",
"=",
"null",
";",
"}",
"}",
"logger",
"info",
"(",
"\"",
"blocking",
"request",
"from",
"master",
"[",
"{",
"}",
"]",
"to",
"[",
"{",
"}",
"]",
"\"",
",",
"master",
"node",
",",
"non",
"master",
"node",
")",
";",
"mock",
"transport",
"service",
"master",
"transport",
"service",
"=",
"(",
"mock",
"transport",
"service",
")",
"internal",
"cluster",
"(",
")",
"get",
"instance",
"(",
"transport",
"service",
"class",
",",
"master",
"node",
")",
";",
"if",
"(",
"random",
"boolean",
"(",
")",
")",
"{",
"master",
"transport",
"service",
"add",
"unresponsive",
"rule",
"(",
"internal",
"cluster",
"(",
")",
"get",
"instance",
"(",
"transport",
"service",
"class",
",",
"non",
"master",
"node",
")",
")",
";",
"}",
"else",
"{",
"master",
"transport",
"service",
"add",
"fail",
"to",
"send",
"no",
"connect",
"rule",
"(",
"internal",
"cluster",
"(",
")",
"get",
"instance",
"(",
"transport",
"service",
"class",
",",
"non",
"master",
"node",
")",
")",
";",
"}",
"logger",
"info",
"(",
"\"",
"waiting",
"for",
"[",
"{",
"}",
"]",
"to",
"be",
"removed",
"from",
"cluster",
"\"",
",",
"non",
"master",
"node",
")",
";",
"ensure",
"stable",
"cluster",
"(",
"2",
",",
"master",
"node",
")",
";",
"logger",
"info",
"(",
"\"",
"waiting",
"for",
"[",
"{",
"}",
"]",
"to",
"have",
"no",
"master",
"\"",
",",
"non",
"master",
"node",
")",
";",
"assert",
"no",
"master",
"(",
"non",
"master",
"node",
")",
";",
"logger",
"info",
"(",
"\"",
"healing",
"partition",
"and",
"checking",
"cluster",
"reforms",
"\"",
")",
";",
"master",
"transport",
"service",
"clear",
"all",
"rules",
"(",
")",
";",
"ensure",
"stable",
"cluster",
"(",
"3",
")",
";",
"}"
]
|
[
"return",
"the",
"currently",
"configured",
"minimum",
"velocity",
"any",
"flings",
"with",
"a",
"magnitude",
"less",
"than",
"this",
"value",
"in",
"pixels",
"per",
"second",
"callback",
"methods",
"accepting",
"a",
"velocity",
"will",
"receive",
"zero",
"as",
"a",
"velocity",
"value",
"if",
"the",
"real",
"detected",
"velocity",
"was",
"below",
"this",
"threshold"
]
| [
"public",
"float",
"get",
"min",
"velocity",
"(",
")",
"{",
"return",
"m",
"min",
"velocity",
";",
"}"
]
|
[
"returns",
"the",
"{",
"@",
"link",
"arguments",
"list",
"type",
"applier",
"}"
]
| [
"arguments",
"list",
"type",
"applier",
"get",
"args",
"list",
"applier",
"(",
")",
"{",
"ms",
"type",
"applier",
"args",
"applier",
"=",
"applicator",
"get",
"type",
"applier",
"(",
"get",
"arg",
"list",
"record",
"number",
"(",
")",
")",
";",
"if",
"(",
"args",
"applier",
"instanceof",
"arguments",
"list",
"type",
"applier",
")",
"{",
"return",
"(",
"arguments",
"list",
"type",
"applier",
")",
"applicator",
"get",
"type",
"applier",
"(",
"get",
"arg",
"list",
"record",
"number",
"(",
")",
")",
";",
"}",
"return",
"null",
";",
"}"
]
|
[
"add",
"a",
"new",
"member",
"to",
"the",
"end",
"of",
"this",
"bit",
"-",
"field",
"group",
"the",
"caller",
"should",
"ensure",
"that",
"the",
"specified",
"member",
"is",
"a",
"suitable",
"addition",
"to",
"this",
"group",
"(",
"must",
"be",
"single",
"bit",
"field",
"whose",
"member",
"offset",
"and",
"length",
"match",
"this",
"group",
"'",
"s",
")"
]
| [
"void",
"add",
"to",
"group",
"(",
"composite",
"member",
"member",
")",
"{",
"list",
"add",
"(",
"validate",
"new",
"member",
"(",
"member",
")",
")",
";",
"}"
]
|
[
"adds",
"the",
"files",
"in",
"{",
"@",
"code",
"inputs",
"}",
"as",
"nodes",
"to",
"{",
"@",
"code",
"tree",
"}",
"this",
"method",
"mutates",
"{",
"@",
"code",
"tree",
"}"
]
| [
"private",
"static",
"int",
"build",
"from",
"action",
"inputs",
"(",
"sorted",
"map",
"<",
"path",
"fragment",
",",
"action",
"input",
">",
"inputs",
",",
"metadata",
"provider",
"metadata",
"provider",
",",
"path",
"exec",
"root",
",",
"digest",
"util",
"digest",
"util",
",",
"map",
"<",
"path",
"fragment",
",",
"directory",
"node",
">",
"tree",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"build",
"(",
"inputs",
",",
"tree",
",",
"(",
"input",
",",
"path",
",",
"curr",
"dir",
")",
"-",
">",
"{",
"if",
"(",
"input",
"instanceof",
"virtual",
"action",
"input",
")",
"{",
"virtual",
"action",
"input",
"virtual",
"action",
"input",
"=",
"(",
"virtual",
"action",
"input",
")",
"input",
";",
"digest",
"d",
"=",
"digest",
"util",
"compute",
"(",
"virtual",
"action",
"input",
")",
";",
"curr",
"dir",
"add",
"child",
"(",
"new",
"file",
"node",
"(",
"path",
"get",
"base",
"name",
"(",
")",
",",
"virtual",
"action",
"input",
"get",
"bytes",
"(",
")",
",",
"d",
")",
")",
";",
"return",
"1",
";",
"}",
"file",
"artifact",
"value",
"metadata",
"=",
"preconditions",
"check",
"not",
"null",
"(",
"metadata",
"provider",
"get",
"metadata",
"(",
"input",
")",
",",
"\"",
"missing",
"metadata",
"for",
"'",
"%",
"s",
"'",
"\"",
",",
"input",
"get",
"exec",
"path",
"string",
"(",
")",
")",
";",
"switch",
"(",
"metadata",
"get",
"type",
"(",
")",
")",
"{",
"case",
"regular",
"file",
":",
"digest",
"d",
"=",
"digest",
"util",
"build",
"digest",
"(",
"metadata",
"get",
"digest",
"(",
")",
",",
"metadata",
"get",
"size",
"(",
")",
")",
";",
"curr",
"dir",
"add",
"child",
"(",
"new",
"file",
"node",
"(",
"path",
"get",
"base",
"name",
"(",
")",
",",
"action",
"input",
"helper",
"to",
"input",
"path",
"(",
"input",
",",
"exec",
"root",
")",
",",
"d",
")",
")",
";",
"return",
"1",
";",
"case",
"directory",
":",
"sorted",
"map",
"<",
"path",
"fragment",
",",
"action",
"input",
">",
"directory",
"inputs",
"=",
"explode",
"directory",
"(",
"path",
",",
"exec",
"root",
")",
";",
"return",
"build",
"from",
"action",
"inputs",
"(",
"directory",
"inputs",
",",
"metadata",
"provider",
",",
"exec",
"root",
",",
"digest",
"util",
",",
"tree",
")",
";",
"case",
"symlink",
":",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"string",
"format",
"(",
"\"",
"encountered",
"symlink",
"input",
"'",
"%",
"s",
"'",
",",
"but",
"all",
"\"",
"+",
"\"",
"symlinks",
"should",
"have",
"been",
"resolved",
"by",
"sky",
"frame",
"this",
"is",
"a",
"bug",
"\"",
",",
"path",
")",
")",
";",
"case",
"special",
"file",
":",
"throw",
"new",
"i",
"o",
"exception",
"(",
"string",
"format",
"(",
"\"",
"the",
"'",
"%",
"s",
"'",
"is",
"a",
"special",
"input",
"which",
"is",
"not",
"supported",
"\"",
"+",
"\"",
"by",
"remote",
"caching",
"and",
"execution",
"\"",
",",
"path",
")",
")",
";",
"case",
"nonexistent",
":",
"throw",
"new",
"i",
"o",
"exception",
"(",
"string",
"format",
"(",
"\"",
"the",
"file",
"type",
"of",
"'",
"%",
"s",
"'",
"is",
"not",
"supported",
"\"",
",",
"path",
")",
")",
";",
"}",
"return",
"0",
";",
"}",
")",
";",
"}"
]
|
[
"similar",
"to",
"the",
"{",
"@",
"link",
"#",
"write",
"block",
"(",
")",
"}",
"method",
"writes",
"a",
"0",
"-",
"length",
"block",
"(",
"without",
"block",
"checksum",
")",
"to",
"signal",
"the",
"end",
"of",
"the",
"block",
"stream"
]
| [
"private",
"void",
"write",
"end",
"mark",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"byte",
"utils",
"write",
"unsigned",
"int",
"l",
"e",
"(",
"out",
",",
"0",
")",
";",
"/",
"/",
"todo",
"implement",
"content",
"checksum",
",",
"update",
"flg",
"validate",
"(",
")",
"}"
]
|
[
"put",
"j",
"s",
"o",
"n",
"array",
"in",
"cache"
]
| [
"public",
"static",
"void",
"put",
"(",
"@",
"non",
"null",
"final",
"string",
"key",
",",
"final",
"j",
"s",
"o",
"n",
"array",
"value",
",",
"final",
"int",
"save",
"time",
",",
"@",
"non",
"null",
"final",
"cache",
"double",
"utils",
"cache",
"double",
"utils",
")",
"{",
"cache",
"double",
"utils",
"put",
"(",
"key",
",",
"value",
",",
"save",
"time",
")",
";",
"}"
]
|
[
"test",
"serialization",
"of",
"outer",
"string",
"types"
]
| [
"public",
"string",
"fake",
"outer",
"string",
"serialize",
"(",
"string",
"body",
")",
"throws",
"api",
"exception",
"{",
"object",
"local",
"var",
"post",
"body",
"=",
"body",
";",
"/",
"/",
"create",
"path",
"and",
"map",
"variables",
"string",
"local",
"var",
"path",
"=",
"\"",
"/",
"fake",
"/",
"outer",
"/",
"string",
"\"",
";",
"/",
"/",
"query",
"params",
"list",
"<",
"pair",
">",
"local",
"var",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"list",
"<",
"pair",
">",
"local",
"var",
"collection",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"header",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"cookie",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"object",
">",
"local",
"var",
"form",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"final",
"string",
"[",
"]",
"local",
"var",
"accepts",
"=",
"{",
"\"",
"*",
"/",
"*",
"\"",
"}",
";",
"final",
"string",
"local",
"var",
"accept",
"=",
"api",
"client",
"select",
"header",
"accept",
"(",
"local",
"var",
"accepts",
")",
";",
"final",
"string",
"[",
"]",
"local",
"var",
"content",
"types",
"=",
"{",
"}",
";",
"final",
"string",
"local",
"var",
"content",
"type",
"=",
"api",
"client",
"select",
"header",
"content",
"type",
"(",
"local",
"var",
"content",
"types",
")",
";",
"string",
"[",
"]",
"local",
"var",
"auth",
"names",
"=",
"new",
"string",
"[",
"]",
"{",
"}",
";",
"generic",
"type",
"<",
"string",
">",
"local",
"var",
"return",
"type",
"=",
"new",
"generic",
"type",
"<",
"string",
">",
"(",
")",
"{",
"}",
";",
"return",
"api",
"client",
"invoke",
"a",
"p",
"i",
"(",
"local",
"var",
"path",
",",
"\"",
"post",
"\"",
",",
"local",
"var",
"query",
"params",
",",
"local",
"var",
"collection",
"query",
"params",
",",
"local",
"var",
"post",
"body",
",",
"local",
"var",
"header",
"params",
",",
"local",
"var",
"cookie",
"params",
",",
"local",
"var",
"form",
"params",
",",
"local",
"var",
"accept",
",",
"local",
"var",
"content",
"type",
",",
"local",
"var",
"auth",
"names",
",",
"local",
"var",
"return",
"type",
")",
";",
"}"
]
|
[
"clears",
"all",
"background",
"colors",
"set",
"on",
"the",
"current",
"program"
]
| [
"public",
"void",
"clear",
"all",
"background",
"colors",
"(",
")",
";"
]
|
[
"get",
"the",
"list",
"of",
"{",
"@",
"linkplain",
"named",
"writeable",
"}",
"s",
"that",
"this",
"class",
"needs"
]
| [
"public",
"static",
"list",
"<",
"named",
"writeable",
"registry",
"entry",
">",
"named",
"writeables",
"(",
")",
"{",
"return",
"arrays",
"as",
"list",
"(",
"new",
"named",
"writeable",
"registry",
"entry",
"(",
"sort",
"value",
"class",
",",
"double",
"sort",
"value",
"name",
",",
"double",
"sort",
"value",
":",
":",
"new",
")",
",",
"new",
"named",
"writeable",
"registry",
"entry",
"(",
"sort",
"value",
"class",
",",
"long",
"sort",
"value",
"name",
",",
"long",
"sort",
"value",
":",
":",
"new",
")",
",",
"new",
"named",
"writeable",
"registry",
"entry",
"(",
"sort",
"value",
"class",
",",
"bytes",
"sort",
"value",
"name",
",",
"bytes",
"sort",
"value",
":",
":",
"new",
")",
")",
";",
"}"
]
|
[
"test",
"that",
"the",
"conversion",
"from",
"a",
"string",
"to",
"enum",
"is",
"correct"
]
| [
"public",
"abstract",
"void",
"test",
"from",
"string",
"(",
")",
";"
]
|
[
"get",
"number",
"minimum",
":",
"32",
"1",
"maximum",
":",
"543",
"2"
]
| [
"@",
"decimal",
"min",
"(",
"\"",
"32",
"1",
"\"",
")",
"@",
"decimal",
"max",
"(",
"\"",
"543",
"2",
"\"",
")",
"public",
"big",
"decimal",
"get",
"number",
"(",
")",
"{",
"return",
"number",
";",
"}"
]
|
[
"writes",
"the",
"current",
"builder",
"parameter",
"values",
"as",
"x",
"content"
]
| [
"public",
"final",
"void",
"to",
"x",
"content",
"(",
"x",
"content",
"builder",
"builder",
",",
"boolean",
"include",
"defaults",
")",
"throws",
"i",
"o",
"exception",
"{",
"for",
"(",
"parameter",
"<",
"?",
">",
"parameter",
":",
"get",
"parameters",
"(",
")",
")",
"{",
"parameter",
"to",
"x",
"content",
"(",
"builder",
",",
"include",
"defaults",
")",
";",
"}",
"}"
]
|
[
"declares",
"that",
"env",
"1",
"fulfills",
"env",
"2"
]
| [
"public",
"environment",
"group",
"maker",
"set",
"fulfills",
"(",
"string",
"env",
"1",
",",
"string",
"env",
"2",
")",
"{",
"fulfills",
"map",
"put",
"(",
"env",
"1",
",",
"env",
"2",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"add",
"{",
"@",
"link",
"common",
"filter",
"}",
"to",
"the",
"server",
",",
"this",
"is",
"the",
"simplest",
"way",
"to",
"use",
"sentinel",
"for",
"web",
"application"
]
| [
"public",
"filter",
"registration",
"bean",
"sentinel",
"filter",
"registration",
"(",
")",
"{",
"filter",
"registration",
"bean",
"<",
"filter",
">",
"registration",
"=",
"new",
"filter",
"registration",
"bean",
"<",
">",
"(",
")",
";",
"registration",
"set",
"filter",
"(",
"new",
"common",
"filter",
"(",
")",
")",
";",
"registration",
"add",
"url",
"patterns",
"(",
"\"",
"/",
"*",
"\"",
")",
";",
"registration",
"set",
"name",
"(",
"\"",
"sentinel",
"filter",
"\"",
")",
";",
"registration",
"set",
"order",
"(",
"1",
")",
";",
"/",
"/",
"if",
"this",
"is",
"enabled",
",",
"the",
"entrance",
"of",
"all",
"web",
"url",
"resources",
"will",
"be",
"unified",
"as",
"a",
"single",
"context",
"name",
"/",
"/",
"in",
"most",
"scenarios",
"that",
"'",
"s",
"enough",
",",
"and",
"it",
"could",
"reduce",
"the",
"memory",
"footprint",
"registration",
"add",
"init",
"parameter",
"(",
"common",
"filter",
"web",
"context",
"unify",
",",
"\"",
"true",
"\"",
")",
";",
"logger",
"info",
"(",
"\"",
"sentinel",
"servlet",
"common",
"filter",
"registered",
"\"",
")",
";",
"return",
"registration",
";",
"}"
]
|
[
"batch",
"sql",
"update",
"does",
"not",
"support",
"blob",
"or",
"clob",
"parameters"
]
| [
"protected",
"boolean",
"supports",
"lob",
"parameters",
"(",
")",
"{",
"return",
"false",
";",
"}"
]
|
[
"return",
"the",
"bytes",
"of",
"md2",
"encryption"
]
| [
"public",
"static",
"byte",
"[",
"]",
"encrypt",
"m",
"d",
"2",
"(",
"final",
"byte",
"[",
"]",
"data",
")",
"{",
"return",
"hash",
"template",
"(",
"data",
",",
"\"",
"md2",
"\"",
")",
";",
"}"
]
|
[
"the",
"largest",
"integer",
"allowed",
"for",
"this",
"xml",
"attribute",
"only",
"makes",
"sense",
"if",
"the",
"format",
"includes",
"format",
"flags",
":",
":",
"integer",
"<",
"code",
">",
"optional",
"int",
"3",
"2",
"max",
"int",
"=",
"3",
";",
"<",
"code",
">"
]
| [
"public",
"int",
"get",
"max",
"int",
"(",
")",
"{",
"return",
"instance",
"get",
"max",
"int",
"(",
")",
";",
"}"
]
|
[
"the",
"value",
"assigned",
"to",
"this",
"element",
"<",
"code",
">",
"optional",
"aapt",
"pb",
"item",
"item",
"=",
"3",
";",
"<",
"code",
">"
]
| [
"public",
"builder",
"set",
"item",
"(",
"com",
"android",
"aapt",
"resources",
"item",
"builder",
"builder",
"for",
"value",
")",
"{",
"copy",
"on",
"write",
"(",
")",
";",
"instance",
"set",
"item",
"(",
"builder",
"for",
"value",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"creates",
"sasl",
"properties",
"required",
"for",
"an",
"encrypted",
"sasl",
"negotiation"
]
| [
"public",
"static",
"map",
"<",
"string",
",",
"string",
">",
"create",
"sasl",
"properties",
"for",
"encryption",
"(",
"string",
"encryption",
"algorithm",
")",
"{",
"map",
"<",
"string",
",",
"string",
">",
"sasl",
"props",
"=",
"maps",
"new",
"hash",
"map",
"with",
"expected",
"size",
"(",
"3",
")",
";",
"sasl",
"props",
"put",
"(",
"sasl",
"qop",
",",
"quality",
"of",
"protection",
"privacy",
"get",
"sasl",
"qop",
"(",
")",
")",
";",
"sasl",
"props",
"put",
"(",
"sasl",
"server",
"auth",
",",
"\"",
"true",
"\"",
")",
";",
"sasl",
"props",
"put",
"(",
"\"",
"com",
"sun",
"security",
"sasl",
"digest",
"cipher",
"\"",
",",
"encryption",
"algorithm",
")",
";",
"return",
"sasl",
"props",
";",
"}"
]
|
[
"get",
"prefix",
"ns",
"boolean"
]
| [
"public",
"boolean",
"get",
"prefix",
"ns",
"boolean",
"(",
")",
"{",
"return",
"prefix",
"ns",
"boolean",
";",
"}"
]
|
[
"returns",
"the",
"account",
"-",
"specific",
"value",
"if",
"it",
"exists",
",",
"then",
"looks",
"for",
"an",
"account",
"-",
"agnostic",
"value"
]
| [
"public",
"string",
"get",
"string",
"(",
"string",
"key",
",",
"string",
"default",
"value",
")",
"{",
"return",
"raw",
"config",
"get",
"(",
"account",
"conf",
"(",
"key",
")",
",",
"raw",
"config",
"get",
"(",
"key",
",",
"default",
"value",
")",
")",
";",
"}"
]
|
[
"string",
"value",
"must",
"not",
"include",
"any",
"secrets"
]
| [
"public",
"string",
"to",
"string",
"(",
")",
"{",
"if",
"(",
"is",
"empty",
"(",
")",
")",
"{",
"return",
"\"",
"empty",
"credentials",
"\"",
";",
"}",
"string",
"validity",
"=",
"is",
"valid",
"(",
"credential",
"type",
"required",
"any",
"non",
"empty",
")",
"?",
"\"",
"valid",
"\"",
":",
"\"",
"invalid",
"\"",
";",
"if",
"(",
"!",
"has",
"session",
"token",
"(",
")",
")",
"{",
"/",
"/",
"full",
"credentials",
"have",
"the",
"simplest",
"string",
"value",
"return",
"\"",
"full",
"credentials",
"(",
"\"",
"+",
"validity",
"+",
"\"",
")",
"\"",
";",
"}",
"else",
"{",
"/",
"/",
"session",
"/",
"role",
"credentials",
"may",
"have",
"an",
"expiry",
"and",
"role",
"arn",
"return",
"string",
"format",
"(",
"\"",
"session",
"credentials",
",",
"expiry",
"%",
"s",
";",
"%",
"s",
"(",
"%",
"s",
")",
"\"",
",",
"get",
"expiration",
"date",
"time",
"(",
")",
"map",
"(",
"x",
"-",
">",
"x",
"format",
"(",
"date",
"time",
"formatter",
"iso",
"date",
"time",
")",
")",
"or",
"else",
"(",
"\"",
"unknown",
"\"",
")",
",",
"(",
"is",
"not",
"empty",
"(",
"role",
"a",
"r",
"n",
")",
"?",
"(",
"\"",
"role",
"\\",
"\"",
"\"",
"+",
"role",
"a",
"r",
"n",
"+",
"\"",
"\\",
"\"",
"\"",
")",
":",
"\"",
"\"",
")",
",",
"validity",
")",
";",
"}",
"}"
]
|
[
"reset",
"the",
"buffer",
"for",
"the",
"next",
"metric",
"to",
"be",
"built"
]
| [
"void",
"reset",
"buffer",
"(",
")",
"{",
"offset",
"=",
"0",
";",
"}"
]
|
[
"model",
"tests",
"for",
"complex",
"quadrilateral"
]
| [
"public",
"void",
"test",
"complex",
"quadrilateral",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"complex",
"quadrilateral",
"}"
]
|
[
"returns",
"the",
"nodes",
"of",
"an",
"acyclic",
"graph",
"in",
"topological",
"order",
"[",
"a",
"k",
"a",
"\"",
"reverse",
"post",
"-",
"order",
"\"",
"of",
"depth",
"-",
"first",
"search",
"]",
"a",
"topological",
"order",
"is",
"one",
"such",
"that",
",",
"if",
"(",
"u",
",",
"v",
")",
"is",
"a",
"path",
"in",
"acyclic",
"graph",
"g",
",",
"then",
"u",
"is",
"before",
"v",
"in",
"the",
"topological",
"order",
"in",
"other",
"words",
"\"",
"tails",
"before",
"heads",
"\"",
"or",
"\"",
"roots",
"before",
"leaves",
"\""
]
| [
"public",
"list",
"<",
"node",
"<",
"t",
">",
">",
"get",
"topological",
"order",
"(",
")",
"{",
"list",
"<",
"node",
"<",
"t",
">",
">",
"order",
"=",
"get",
"postorder",
"(",
")",
";",
"collections",
"reverse",
"(",
"order",
")",
";",
"return",
"order",
";",
"}"
]
|
[
"create",
"key",
"bindings",
"for",
"the",
"slider",
"these",
"are",
"also",
"captured",
"by",
"the",
"{",
"@",
"link",
"f",
"v",
"table",
"}",
",",
"but",
"if",
"focus",
"is",
"on",
"this",
"slider",
"we",
"still",
"want",
"these",
"keys",
"to",
"work",
"we",
"have",
"to",
"capture",
"the",
"following",
":",
"-",
"arrow",
"down",
"-",
"arrow",
"up",
"-",
"page",
"down",
"-",
"page",
"up",
"-",
"home",
"-",
"end",
"-",
"ctrl",
"-",
"c",
"(",
"command",
"-",
"c",
"for",
"mac",
")",
"for",
"copy",
"-",
"ctrl",
"-",
"a",
"(",
"command",
"-",
"a",
"for",
"mac",
")",
"for",
"select",
"all",
"-",
"shift",
"pressed",
"-",
"shift",
"released"
]
| [
"private",
"void",
"create",
"key",
"bindings",
"(",
"f",
"v",
"table",
"table",
",",
"chunk",
"model",
"model",
",",
"chunk",
"reader",
"reader",
",",
"f",
"v",
"event",
"listener",
"event",
"listener",
")",
"{",
"/",
"/",
"these",
"key",
"bindings",
"are",
"identical",
"to",
"the",
"ones",
"set",
"in",
"the",
"f",
"v",
"table",
"class",
"these",
"are",
"/",
"/",
"necessary",
"for",
"cases",
"where",
"the",
"user",
"hits",
"a",
"key",
"that",
"should",
"manipulate",
"the",
"table",
",",
"but",
"/",
"/",
"keyboard",
"focus",
"is",
"on",
"the",
"slider",
"input",
"map",
"im",
"table",
"=",
"get",
"input",
"map",
"(",
")",
";",
"action",
"map",
"am",
"table",
"=",
"get",
"action",
"map",
"(",
")",
";",
"im",
"table",
"put",
"(",
"key",
"stroke",
"get",
"key",
"stroke",
"(",
"key",
"event",
"vk",
"down",
",",
"0",
")",
",",
"\"",
"down",
"arrow",
"\"",
")",
";",
"am",
"table",
"put",
"(",
"\"",
"down",
"arrow",
"\"",
",",
"new",
"arrow",
"down",
"action",
"(",
"event",
"listener",
")",
")",
";",
"im",
"table",
"put",
"(",
"key",
"stroke",
"get",
"key",
"stroke",
"(",
"key",
"event",
"vk",
"up",
",",
"0",
")",
",",
"\"",
"up",
"arrow",
"\"",
")",
";",
"am",
"table",
"put",
"(",
"\"",
"up",
"arrow",
"\"",
",",
"new",
"arrow",
"up",
"action",
"(",
"event",
"listener",
")",
")",
";",
"im",
"table",
"put",
"(",
"key",
"stroke",
"get",
"key",
"stroke",
"(",
"key",
"event",
"vk",
"page",
"down",
",",
"0",
")",
",",
"\"",
"page",
"down",
"\"",
")",
";",
"am",
"table",
"put",
"(",
"\"",
"page",
"down",
"\"",
",",
"new",
"page",
"down",
"action",
"(",
"event",
"listener",
")",
")",
";",
"im",
"table",
"put",
"(",
"key",
"stroke",
"get",
"key",
"stroke",
"(",
"key",
"event",
"vk",
"page",
"up",
",",
"0",
")",
",",
"\"",
"page",
"up",
"\"",
")",
";",
"am",
"table",
"put",
"(",
"\"",
"page",
"up",
"\"",
",",
"new",
"page",
"up",
"action",
"(",
"event",
"listener",
")",
")",
";",
"im",
"table",
"put",
"(",
"key",
"stroke",
"get",
"key",
"stroke",
"(",
"key",
"event",
"vk",
"home",
",",
"0",
")",
",",
"\"",
"home",
"\"",
")",
";",
"am",
"table",
"put",
"(",
"\"",
"home",
"\"",
",",
"new",
"home",
"action",
"(",
"event",
"listener",
")",
")",
";",
"im",
"table",
"put",
"(",
"key",
"stroke",
"get",
"key",
"stroke",
"(",
"key",
"event",
"vk",
"end",
",",
"0",
")",
",",
"\"",
"end",
"\"",
")",
";",
"am",
"table",
"put",
"(",
"\"",
"end",
"\"",
",",
"new",
"end",
"action",
"(",
"event",
"listener",
")",
")",
";",
"/",
"/",
"recognize",
"when",
"the",
"shift",
"key",
"has",
"been",
"pressed",
"and",
"released",
",",
"so",
"we",
"know",
"how",
"to",
"handle",
"/",
"/",
"selection",
"im",
"table",
"put",
"(",
"key",
"stroke",
"get",
"key",
"stroke",
"(",
"key",
"event",
"vk",
"shift",
",",
"input",
"event",
"shift",
"down",
"mask",
",",
"false",
")",
",",
"\"",
"shift",
"pressed",
"\"",
")",
";",
"am",
"table",
"put",
"(",
"\"",
"shift",
"pressed",
"\"",
",",
"new",
"abstract",
"action",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"action",
"performed",
"(",
"action",
"event",
"e",
")",
"{",
"table",
"set",
"shift",
"down",
"(",
"true",
")",
";",
"}",
"}",
")",
";",
"im",
"table",
"put",
"(",
"key",
"stroke",
"get",
"key",
"stroke",
"(",
"\"",
"released",
"shift",
"\"",
")",
",",
"\"",
"shift",
"released",
"\"",
")",
";",
"am",
"table",
"put",
"(",
"\"",
"shift",
"released",
"\"",
",",
"new",
"abstract",
"action",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"action",
"performed",
"(",
"action",
"event",
"e",
")",
"{",
"table",
"set",
"shift",
"down",
"(",
"false",
")",
";",
"}",
"}",
")",
";",
"/",
"/",
"now",
"create",
"a",
"binding",
"for",
"the",
"ctrl",
"-",
"a",
",",
"select",
"all",
"action",
"im",
"table",
"put",
"(",
"key",
"stroke",
"get",
"key",
"stroke",
"(",
"key",
"event",
"vk",
"a",
",",
"input",
"event",
"ctrl",
"down",
"mask",
",",
"false",
")",
",",
"\"",
"select",
"all",
"\"",
")",
";",
"im",
"table",
"put",
"(",
"key",
"stroke",
"get",
"key",
"stroke",
"(",
"key",
"event",
"vk",
"a",
",",
"input",
"event",
"meta",
"down",
"mask",
",",
"false",
")",
",",
"\"",
"select",
"all",
"\"",
")",
";",
"am",
"table",
"put",
"(",
"\"",
"select",
"all",
"\"",
",",
"new",
"abstract",
"action",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"action",
"performed",
"(",
"action",
"event",
"e",
")",
"{",
"try",
"{",
"model",
"selected",
"byte",
"start",
"=",
"0",
";",
"model",
"selected",
"byte",
"end",
"=",
"reader",
"get",
"file",
"size",
"(",
")",
"-",
"1",
";",
"f",
"v",
"event",
"copy",
"evt",
"=",
"new",
"f",
"v",
"event",
"(",
"event",
"type",
"copy",
"selection",
",",
"null",
")",
";",
"event",
"listener",
"send",
"(",
"copy",
"evt",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
"1",
")",
"{",
"msg",
"error",
"(",
"this",
",",
"\"",
"error",
"reading",
"file",
"size",
"\"",
",",
"e",
"1",
")",
";",
"}",
"}",
"}",
")",
";",
"}"
]
|
[
"is",
"the",
"the",
"capacity",
"that",
"of",
"an",
"on",
"-",
"demand",
"table",
"?"
]
| [
"public",
"boolean",
"is",
"on",
"demand",
"table",
"(",
")",
"{",
"return",
"read",
"=",
"=",
"0",
"&",
"&",
"write",
"=",
"=",
"0",
";",
"}"
]
|
[
"a",
"list",
"of",
"alternate",
"names",
"to",
"verify",
"the",
"subject",
"identity",
"in",
"the",
"certificate",
"presented",
"by",
"the",
"client",
"<",
"code",
">",
"repeated",
"string",
"subject",
"alt",
"names",
"=",
"6",
";",
"<",
"code",
">"
]
| [
"public",
"builder",
"add",
"subject",
"alt",
"names",
"bytes",
"(",
"com",
"google",
"protobuf",
"byte",
"string",
"value",
")",
"{",
"if",
"(",
"value",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"null",
"pointer",
"exception",
"(",
")",
";",
"}",
"check",
"byte",
"string",
"is",
"utf",
"8",
"(",
"value",
")",
";",
"ensure",
"subject",
"alt",
"names",
"is",
"mutable",
"(",
")",
";",
"subject",
"alt",
"names",
"add",
"(",
"value",
")",
";",
"on",
"changed",
"(",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"sets",
"auxiliary",
"object",
"which",
"will",
"be",
"passed",
"to",
"{",
"@",
"link",
"image",
"downloader",
"#",
"get",
"stream",
"(",
"string",
",",
"object",
")",
"}"
]
| [
"public",
"builder",
"extra",
"for",
"downloader",
"(",
"object",
"extra",
")",
"{",
"this",
"extra",
"for",
"downloader",
"=",
"extra",
";",
"return",
"this",
";",
"}"
]
|
[
"same",
"as",
"{",
"@",
"link",
"#",
"suspend",
"default",
"action",
"(",
"timer",
"gauge",
")",
"}",
"but",
"without",
"any",
"associated",
"timer",
"measuring",
"the",
"idle",
"time"
]
| [
"suspension",
"suspend",
"default",
"action",
"(",
")",
";"
]
|
[
"called",
"by",
"create",
"huffman",
"decoding",
"tables",
"(",
")",
"exclusively"
]
| [
"private",
"static",
"void",
"hb",
"create",
"decode",
"tables",
"(",
"final",
"int",
"[",
"]",
"limit",
",",
"final",
"int",
"[",
"]",
"base",
",",
"final",
"int",
"[",
"]",
"perm",
",",
"final",
"char",
"[",
"]",
"length",
",",
"final",
"int",
"min",
"len",
",",
"final",
"int",
"max",
"len",
",",
"final",
"int",
"alpha",
"size",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"min",
"len",
",",
"pp",
"=",
"0",
";",
"i",
"<",
"=",
"max",
"len",
";",
"i",
"+",
"+",
")",
"{",
"for",
"(",
"int",
"j",
"=",
"0",
";",
"j",
"<",
"alpha",
"size",
";",
"j",
"+",
"+",
")",
"{",
"if",
"(",
"length",
"[",
"j",
"]",
"=",
"=",
"i",
")",
"{",
"perm",
"[",
"pp",
"+",
"+",
"]",
"=",
"j",
";",
"}",
"}",
"}",
"for",
"(",
"int",
"i",
"=",
"max",
"code",
"len",
";",
"-",
"-",
"i",
">",
"0",
";",
")",
"{",
"base",
"[",
"i",
"]",
"=",
"0",
";",
"limit",
"[",
"i",
"]",
"=",
"0",
";",
"}",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"alpha",
"size",
";",
"i",
"+",
"+",
")",
"{",
"base",
"[",
"length",
"[",
"i",
"]",
"+",
"1",
"]",
"+",
"+",
";",
"}",
"for",
"(",
"int",
"i",
"=",
"1",
",",
"b",
"=",
"base",
"[",
"0",
"]",
";",
"i",
"<",
"max",
"code",
"len",
";",
"i",
"+",
"+",
")",
"{",
"b",
"+",
"=",
"base",
"[",
"i",
"]",
";",
"base",
"[",
"i",
"]",
"=",
"b",
";",
"}",
"for",
"(",
"int",
"i",
"=",
"min",
"len",
",",
"vec",
"=",
"0",
",",
"b",
"=",
"base",
"[",
"i",
"]",
";",
"i",
"<",
"=",
"max",
"len",
";",
"i",
"+",
"+",
")",
"{",
"final",
"int",
"nb",
"=",
"base",
"[",
"i",
"+",
"1",
"]",
";",
"vec",
"+",
"=",
"nb",
"-",
"b",
";",
"b",
"=",
"nb",
";",
"limit",
"[",
"i",
"]",
"=",
"vec",
"-",
"1",
";",
"vec",
"<",
"<",
"=",
"1",
";",
"}",
"for",
"(",
"int",
"i",
"=",
"min",
"len",
"+",
"1",
";",
"i",
"<",
"=",
"max",
"len",
";",
"i",
"+",
"+",
")",
"{",
"base",
"[",
"i",
"]",
"=",
"(",
"(",
"limit",
"[",
"i",
"-",
"1",
"]",
"+",
"1",
")",
"<",
"<",
"1",
")",
"-",
"base",
"[",
"i",
"]",
";",
"}",
"}"
]
|
[
"sets",
"client",
"id"
]
| [
"public",
"void",
"set",
"client",
"id",
"(",
"string",
"client",
"id",
")",
"{",
"this",
"client",
"id",
"=",
"client",
"id",
";",
"}"
]
|
[
"verifies",
"that",
"user",
"provided",
"plan",
"is",
"valid"
]
| [
"private",
"node",
"plan",
"verify",
"plan",
"(",
"string",
"plan",
"i",
"d",
",",
"long",
"plan",
"version",
",",
"string",
"plan",
",",
"boolean",
"force",
")",
"throws",
"disk",
"balancer",
"exception",
"{",
"preconditions",
"check",
"state",
"(",
"lock",
"is",
"held",
"by",
"current",
"thread",
"(",
")",
")",
";",
"verify",
"plan",
"version",
"(",
"plan",
"version",
")",
";",
"node",
"plan",
"node",
"plan",
"=",
"verify",
"plan",
"hash",
"(",
"plan",
"i",
"d",
",",
"plan",
")",
";",
"if",
"(",
"!",
"force",
")",
"{",
"verify",
"time",
"stamp",
"(",
"node",
"plan",
")",
";",
"}",
"verify",
"node",
"u",
"u",
"i",
"d",
"(",
"node",
"plan",
")",
";",
"return",
"node",
"plan",
";",
"}"
]
|
[
"copies",
"stream",
",",
"fires",
"progress",
"events",
"by",
"listener",
",",
"can",
"be",
"interrupted",
"by",
"listener"
]
| [
"public",
"static",
"boolean",
"copy",
"stream",
"(",
"input",
"stream",
"is",
",",
"output",
"stream",
"os",
",",
"copy",
"listener",
"listener",
",",
"int",
"buffer",
"size",
")",
"throws",
"i",
"o",
"exception",
"{",
"int",
"current",
"=",
"0",
";",
"int",
"total",
"=",
"is",
"available",
"(",
")",
";",
"if",
"(",
"total",
"<",
"=",
"0",
")",
"{",
"total",
"=",
"default",
"image",
"total",
"size",
";",
"}",
"final",
"byte",
"[",
"]",
"bytes",
"=",
"new",
"byte",
"[",
"buffer",
"size",
"]",
";",
"int",
"count",
";",
"if",
"(",
"should",
"stop",
"loading",
"(",
"listener",
",",
"current",
",",
"total",
")",
")",
"return",
"false",
";",
"while",
"(",
"(",
"count",
"=",
"is",
"read",
"(",
"bytes",
",",
"0",
",",
"buffer",
"size",
")",
")",
"!",
"=",
"-",
"1",
")",
"{",
"os",
"write",
"(",
"bytes",
",",
"0",
",",
"count",
")",
";",
"current",
"+",
"=",
"count",
";",
"if",
"(",
"should",
"stop",
"loading",
"(",
"listener",
",",
"current",
",",
"total",
")",
")",
"return",
"false",
";",
"}",
"os",
"flush",
"(",
")",
";",
"return",
"true",
";",
"}"
]
|
[
"grows",
"the",
"map",
"size",
"after",
"an",
"insertion",
"if",
"necessary",
",",
"performs",
"a",
"rehash",
"of",
"the",
"map"
]
| [
"private",
"void",
"grow",
"size",
"(",
")",
"{",
"size",
"+",
"+",
";",
"if",
"(",
"size",
">",
"max",
"size",
")",
"{",
"if",
"(",
"keys",
"length",
"=",
"=",
"integer",
"max",
"value",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"max",
"capacity",
"reached",
"at",
"size",
"=",
"\"",
"+",
"size",
")",
";",
"}",
"/",
"/",
"double",
"the",
"capacity",
"rehash",
"(",
"keys",
"length",
"<",
"<",
"1",
")",
";",
"}",
"}"
]
|
[
"get",
"the",
"job",
"token",
"secret"
]
| [
"public",
"secret",
"key",
"get",
"job",
"token",
"secret",
"(",
")",
"{",
"return",
"this",
"token",
"secret",
";",
"}"
]
|
[
"verify",
"that",
"an",
"fs",
"is",
"an",
"s3a",
"fs"
]
| [
"public",
"static",
"s",
"3",
"a",
"file",
"system",
"verify",
"is",
"s",
"3",
"a",
"f",
"s",
"(",
"file",
"system",
"fs",
",",
"path",
"path",
")",
"throws",
"path",
"commit",
"exception",
"{",
"if",
"(",
"!",
"(",
"fs",
"instanceof",
"s",
"3",
"a",
"file",
"system",
")",
")",
"{",
"throw",
"new",
"path",
"commit",
"exception",
"(",
"path",
",",
"e",
"wrong",
"fs",
")",
";",
"}",
"return",
"(",
"s",
"3",
"a",
"file",
"system",
")",
"fs",
";",
"}"
]
|
[
"parse",
"a",
"zoo",
"keeper",
"configuration",
"file"
]
| [
"public",
"void",
"parse",
"(",
"string",
"path",
")",
"throws",
"config",
"exception",
"{",
"log",
"info",
"(",
"\"",
"reading",
"configuration",
"from",
":",
"\"",
"+",
"path",
")",
";",
"try",
"{",
"file",
"config",
"file",
"=",
"(",
"new",
"verifying",
"file",
"factory",
"builder",
"(",
"log",
")",
"warn",
"for",
"relative",
"path",
"(",
")",
"fail",
"for",
"non",
"existing",
"path",
"(",
")",
"build",
"(",
")",
")",
"create",
"(",
"path",
")",
";",
"properties",
"cfg",
"=",
"new",
"properties",
"(",
")",
";",
"file",
"input",
"stream",
"in",
"=",
"new",
"file",
"input",
"stream",
"(",
"config",
"file",
")",
";",
"try",
"{",
"cfg",
"load",
"(",
"in",
")",
";",
"config",
"file",
"str",
"=",
"path",
";",
"}",
"finally",
"{",
"in",
"close",
"(",
")",
";",
"}",
"/",
"*",
"read",
"entire",
"config",
"file",
"as",
"initial",
"configuration",
"*",
"/",
"initial",
"config",
"=",
"new",
"string",
"(",
"files",
"read",
"all",
"bytes",
"(",
"config",
"file",
"to",
"path",
"(",
")",
")",
")",
";",
"parse",
"properties",
"(",
"cfg",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"throw",
"new",
"config",
"exception",
"(",
"\"",
"error",
"processing",
"\"",
"+",
"path",
",",
"e",
")",
";",
"}",
"catch",
"(",
"illegal",
"argument",
"exception",
"e",
")",
"{",
"throw",
"new",
"config",
"exception",
"(",
"\"",
"error",
"processing",
"\"",
"+",
"path",
",",
"e",
")",
";",
"}",
"if",
"(",
"dynamic",
"config",
"file",
"str",
"!",
"=",
"null",
")",
"{",
"try",
"{",
"properties",
"dynamic",
"cfg",
"=",
"new",
"properties",
"(",
")",
";",
"file",
"input",
"stream",
"in",
"config",
"=",
"new",
"file",
"input",
"stream",
"(",
"dynamic",
"config",
"file",
"str",
")",
";",
"try",
"{",
"dynamic",
"cfg",
"load",
"(",
"in",
"config",
")",
";",
"if",
"(",
"dynamic",
"cfg",
"get",
"property",
"(",
"\"",
"version",
"\"",
")",
"!",
"=",
"null",
")",
"{",
"throw",
"new",
"config",
"exception",
"(",
"\"",
"dynamic",
"file",
"shouldn",
"'",
"t",
"have",
"version",
"inside",
"\"",
")",
";",
"}",
"string",
"version",
"=",
"get",
"version",
"from",
"filename",
"(",
"dynamic",
"config",
"file",
"str",
")",
";",
"/",
"/",
"if",
"there",
"isn",
"'",
"t",
"any",
"version",
"associated",
"with",
"the",
"filename",
",",
"/",
"/",
"the",
"default",
"version",
"is",
"0",
"if",
"(",
"version",
"!",
"=",
"null",
")",
"{",
"dynamic",
"cfg",
"set",
"property",
"(",
"\"",
"version",
"\"",
",",
"version",
")",
";",
"}",
"}",
"finally",
"{",
"in",
"config",
"close",
"(",
")",
";",
"}",
"setup",
"quorum",
"peer",
"config",
"(",
"dynamic",
"cfg",
",",
"false",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"throw",
"new",
"config",
"exception",
"(",
"\"",
"error",
"processing",
"\"",
"+",
"dynamic",
"config",
"file",
"str",
",",
"e",
")",
";",
"}",
"catch",
"(",
"illegal",
"argument",
"exception",
"e",
")",
"{",
"throw",
"new",
"config",
"exception",
"(",
"\"",
"error",
"processing",
"\"",
"+",
"dynamic",
"config",
"file",
"str",
",",
"e",
")",
";",
"}",
"file",
"next",
"dynamic",
"config",
"file",
"=",
"new",
"file",
"(",
"config",
"file",
"str",
"+",
"next",
"dynamic",
"config",
"file",
"suffix",
")",
";",
"if",
"(",
"next",
"dynamic",
"config",
"file",
"exists",
"(",
")",
")",
"{",
"try",
"{",
"properties",
"dynamic",
"config",
"next",
"cfg",
"=",
"new",
"properties",
"(",
")",
";",
"file",
"input",
"stream",
"in",
"config",
"next",
"=",
"new",
"file",
"input",
"stream",
"(",
"next",
"dynamic",
"config",
"file",
")",
";",
"try",
"{",
"dynamic",
"config",
"next",
"cfg",
"load",
"(",
"in",
"config",
"next",
")",
";",
"}",
"finally",
"{",
"in",
"config",
"next",
"close",
"(",
")",
";",
"}",
"boolean",
"is",
"hierarchical",
"=",
"false",
";",
"for",
"(",
"entry",
"<",
"object",
",",
"object",
">",
"entry",
":",
"dynamic",
"config",
"next",
"cfg",
"entry",
"set",
"(",
")",
")",
"{",
"string",
"key",
"=",
"entry",
"get",
"key",
"(",
")",
"to",
"string",
"(",
")",
"trim",
"(",
")",
";",
"if",
"(",
"key",
"starts",
"with",
"(",
"\"",
"group",
"\"",
")",
"|",
"|",
"key",
"starts",
"with",
"(",
"\"",
"weight",
"\"",
")",
")",
"{",
"is",
"hierarchical",
"=",
"true",
";",
"break",
";",
"}",
"}",
"last",
"seen",
"quorum",
"verifier",
"=",
"create",
"quorum",
"verifier",
"(",
"dynamic",
"config",
"next",
"cfg",
",",
"is",
"hierarchical",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"log",
"warn",
"(",
"\"",
"next",
"quorum",
"verifier",
"is",
"initiated",
"to",
"null",
"\"",
")",
";",
"}",
"}",
"}",
"}"
]
|
[
"ensure",
"specifying",
"wildcard",
"ipv",
"4",
"address",
"selects",
"reasonable",
"publish",
"address"
]
| [
"public",
"void",
"test",
"publish",
"any",
"local",
"v",
"4",
"(",
")",
"throws",
"exception",
"{",
"network",
"service",
"service",
"=",
"new",
"network",
"service",
"(",
"collections",
"empty",
"list",
"(",
")",
")",
";",
"inet",
"address",
"address",
"=",
"service",
"resolve",
"publish",
"host",
"addresses",
"(",
"new",
"string",
"[",
"]",
"{",
"\"",
"0",
"0",
"0",
"0",
"\"",
"}",
")",
";",
"assert",
"false",
"(",
"address",
"is",
"any",
"local",
"address",
"(",
")",
")",
";",
"}"
]
|
[
"returns",
"true",
"iff",
"the",
"vertex",
"is",
"in",
"the",
"graph"
]
| [
"public",
"boolean",
"contains",
"(",
"vertex",
"v",
")",
"{",
"return",
"this",
"vertices",
"(",
")",
"contains",
"(",
"v",
")",
";",
"}"
]
|
[
"skips",
"{",
"@",
"code",
"amount",
"}",
"characters",
"in",
"this",
"reader",
"subsequent",
"calls",
"of",
"{",
"@",
"code",
"read",
"}",
"methods",
"will",
"not",
"return",
"these",
"characters",
"unless",
"{",
"@",
"code",
"reset",
"(",
")",
"}",
"is",
"used",
"this",
"method",
"may",
"perform",
"multiple",
"reads",
"to",
"read",
"{",
"@",
"code",
"count",
"}",
"characters"
]
| [
"public",
"long",
"skip",
"(",
"long",
"count",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"count",
"<",
"0",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
")",
";",
"}",
"synchronized",
"(",
"lock",
")",
"{",
"long",
"skipped",
"=",
"0",
";",
"int",
"to",
"read",
"=",
"count",
"<",
"512",
"?",
"(",
"int",
")",
"count",
":",
"512",
";",
"char",
"chars",
"skipped",
"[",
"]",
"=",
"new",
"char",
"[",
"to",
"read",
"]",
";",
"while",
"(",
"skipped",
"<",
"count",
")",
"{",
"int",
"read",
"=",
"read",
"(",
"chars",
"skipped",
",",
"0",
",",
"to",
"read",
")",
";",
"if",
"(",
"read",
"=",
"=",
"-",
"1",
")",
"{",
"return",
"skipped",
";",
"}",
"skipped",
"+",
"=",
"read",
";",
"if",
"(",
"read",
"<",
"to",
"read",
")",
"{",
"return",
"skipped",
";",
"}",
"if",
"(",
"count",
"-",
"skipped",
"<",
"to",
"read",
")",
"{",
"to",
"read",
"=",
"(",
"int",
")",
"(",
"count",
"-",
"skipped",
")",
";",
"}",
"}",
"return",
"skipped",
";",
"}",
"}"
]
|
[
"the",
"value",
"assigned",
"to",
"this",
"plural",
"<",
"code",
">",
"optional",
"aapt",
"pb",
"item",
"item",
"=",
"4",
";",
"<",
"code",
">"
]
| [
"public",
"builder",
"clear",
"item",
"(",
")",
"{",
"copy",
"on",
"write",
"(",
")",
";",
"instance",
"clear",
"item",
"(",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"for",
"testing",
"-",
"purpose"
]
| [
"int",
"size",
"(",
")",
"{",
"return",
"map",
"size",
"(",
")",
";",
"}"
]
|
[
"the",
"specification",
"of",
"this",
"method",
"matches",
"that",
"of",
"{",
"@",
"link",
"file",
"context",
"#",
"get",
"fs",
"status",
"(",
"path",
")",
"}"
]
| [
"public",
"abstract",
"fs",
"status",
"get",
"fs",
"status",
"(",
")",
"throws",
"access",
"control",
"exception",
",",
"file",
"not",
"found",
"exception",
",",
"i",
"o",
"exception",
";"
]
|
[
"returns",
"the",
"first",
"artifact",
"which",
"is",
"an",
"input",
"to",
"\"",
"action",
"\"",
"and",
"has",
"the",
"specified",
"basename",
"an",
"assertion",
"error",
"is",
"raised",
"if",
"none",
"is",
"found"
]
| [
"public",
"static",
"artifact",
"get",
"input",
"(",
"action",
"analysis",
"metadata",
"action",
",",
"string",
"basename",
")",
"{",
"for",
"(",
"artifact",
"artifact",
":",
"action",
"get",
"inputs",
"(",
")",
"to",
"list",
"(",
")",
")",
"{",
"if",
"(",
"artifact",
"get",
"exec",
"path",
"(",
")",
"get",
"base",
"name",
"(",
")",
"equals",
"(",
"basename",
")",
")",
"{",
"return",
"artifact",
";",
"}",
"}",
"throw",
"new",
"assertion",
"error",
"(",
"\"",
"no",
"input",
"with",
"basename",
"'",
"\"",
"+",
"basename",
"+",
"\"",
"'",
"in",
"action",
"\"",
"+",
"action",
")",
";",
"}"
]
|
[
"checks",
"whether",
"the",
"given",
"feature",
"is",
"allowed",
"by",
"the",
"current",
"license",
"this",
"method",
"should",
"only",
"be",
"used",
"when",
"serializing",
"whether",
"a",
"feature",
"is",
"allowed",
"for",
"telemetry"
]
| [
"public",
"boolean",
"is",
"allowed",
"(",
"feature",
"feature",
")",
"{",
"return",
"is",
"allowed",
"by",
"license",
"(",
"feature",
"minimum",
"operation",
"mode",
",",
"feature",
"needs",
"active",
")",
";",
"}"
]
|
[
"adds",
"a",
"single",
"object",
"file",
"to",
"the",
"set",
"of",
"inputs"
]
| [
"public",
"cpp",
"link",
"action",
"builder",
"add",
"object",
"file",
"(",
"artifact",
"input",
")",
"{",
"add",
"object",
"file",
"(",
"linker",
"inputs",
"simple",
"linker",
"input",
"(",
"input",
",",
"artifact",
"category",
"object",
"file",
",",
"/",
"*",
"disable",
"whole",
"archive",
"=",
"*",
"/",
"false",
",",
"input",
"get",
"root",
"relative",
"path",
"string",
"(",
")",
")",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"release",
"a",
"byte",
"buffer",
"which",
"was",
"created",
"by",
"the",
"enhanced",
"byte",
"buffer",
"read",
"function",
"you",
"must",
"not",
"continue",
"using",
"the",
"byte",
"buffer",
"after",
"calling",
"this",
"function"
]
| [
"public",
"void",
"release",
"buffer",
"(",
"byte",
"buffer",
"buffer",
")",
";"
]
|
[
"register",
"a",
"qualifier",
"to",
"be",
"used",
"for",
"autowire",
"candidate",
"resolution",
",",
"keyed",
"by",
"the",
"qualifier",
"'",
"s",
"type",
"name"
]
| [
"public",
"void",
"add",
"qualifier",
"(",
"autowire",
"candidate",
"qualifier",
"qualifier",
")",
"{",
"this",
"qualifiers",
"put",
"(",
"qualifier",
"get",
"type",
"name",
"(",
")",
",",
"qualifier",
")",
";",
"}"
]
|
[
"gets",
"the",
"{",
"@",
"link",
"configuration",
"}"
]
| [
"public",
"configuration",
"get",
"conf",
"(",
")",
"{",
"return",
"this",
"conf",
";",
"}"
]
|
[
"returns",
"a",
"canonical",
"x",
"content",
"type",
"for",
"this",
"x",
"content",
"type",
"a",
"canonical",
"x",
"content",
"type",
"is",
"used",
"to",
"serialize",
"or",
"deserialize",
"the",
"data",
"fromto",
"for",
"http",
"more",
"specialized",
"x",
"content",
"type",
"types",
"such",
"as",
"vnd",
"variants",
"still",
"use",
"the",
"general",
"data",
"structure",
",",
"but",
"may",
"have",
"semantic",
"differences",
"example",
":",
"x",
"content",
"type",
"vnd",
"json",
"has",
"a",
"canonical",
"x",
"content",
"type",
"json",
"x",
"content",
"type",
"json",
"has",
"a",
"canonical",
"x",
"content",
"type",
"json"
]
| [
"public",
"x",
"content",
"type",
"canonical",
"(",
")",
"{",
"return",
"this",
";",
"}"
]
|
[
"gets",
"the",
"base",
"address",
"of",
"the",
"next",
"action",
"record",
"to",
"consider",
"in",
"the",
"action",
"table"
]
| [
"public",
"address",
"get",
"next",
"action",
"address",
"(",
")",
"{",
"return",
"next",
"action",
"address",
";",
"}"
]
|
[
"clone",
"this",
"{",
"@",
"link",
"web",
"http",
"handler",
"builder",
"}"
]
| [
"public",
"web",
"http",
"handler",
"builder",
"clone",
"(",
")",
"{",
"return",
"new",
"web",
"http",
"handler",
"builder",
"(",
"this",
")",
";",
"}"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.