docstring_tokens
list | code_tokens
list |
|---|---|
[
"on",
"machine",
"logoff"
]
| [
"protected",
"void",
"on",
"machine",
"logoff",
"(",
"int",
"session",
"id",
")",
"{",
"system",
"out",
"println",
"(",
"\"",
"on",
"machine",
"logoff",
":",
"\"",
"+",
"session",
"id",
")",
";",
"}"
]
|
[
"analyze",
"the",
"{",
"@",
"link",
"star",
"loop",
"entry",
"state",
"}",
"states",
"in",
"the",
"specified",
"atn",
"to",
"set",
"the",
"{",
"@",
"link",
"star",
"loop",
"entry",
"state",
"#",
"is",
"precedence",
"decision",
"}",
"field",
"to",
"the",
"correct",
"value"
]
| [
"protected",
"void",
"mark",
"precedence",
"decisions",
"(",
"atn",
"atn",
")",
"{",
"for",
"(",
"a",
"t",
"n",
"state",
"state",
":",
"atn",
"states",
")",
"{",
"if",
"(",
"!",
"(",
"state",
"instanceof",
"star",
"loop",
"entry",
"state",
")",
")",
"{",
"continue",
";",
"}",
"/",
"*",
"we",
"analyze",
"the",
"atn",
"to",
"determine",
"if",
"this",
"atn",
"decision",
"state",
"is",
"the",
"*",
"decision",
"for",
"the",
"closure",
"block",
"that",
"determines",
"whether",
"a",
"*",
"precedence",
"rule",
"should",
"continue",
"or",
"complete",
"*",
"/",
"if",
"(",
"atn",
"rule",
"to",
"start",
"state",
"[",
"state",
"rule",
"index",
"]",
"is",
"left",
"recursive",
"rule",
")",
"{",
"a",
"t",
"n",
"state",
"maybe",
"loop",
"end",
"state",
"=",
"state",
"transition",
"(",
"state",
"get",
"number",
"of",
"transitions",
"(",
")",
"-",
"1",
")",
"target",
";",
"if",
"(",
"maybe",
"loop",
"end",
"state",
"instanceof",
"loop",
"end",
"state",
")",
"{",
"if",
"(",
"maybe",
"loop",
"end",
"state",
"epsilon",
"only",
"transitions",
"&",
"&",
"maybe",
"loop",
"end",
"state",
"transition",
"(",
"0",
")",
"target",
"instanceof",
"rule",
"stop",
"state",
")",
"{",
"(",
"(",
"star",
"loop",
"entry",
"state",
")",
"state",
")",
"is",
"precedence",
"decision",
"=",
"true",
";",
"}",
"}",
"}",
"}",
"}"
]
|
[
"determine",
"the",
"maximum",
"number",
"of",
"array",
"elements",
"that",
"can",
"be",
"created",
"for",
"the",
"current",
"selection",
"the",
"array",
"data",
"type",
"is",
"assumed",
"to",
"become",
"the",
"data",
"type",
"of",
"the",
"first",
"component",
"in",
"the",
"selection",
"the",
"current",
"selection",
"must",
"be",
"contiguous",
"or",
"0",
"is",
"returned"
]
| [
"public",
"int",
"get",
"max",
"elements",
"(",
")",
"{",
"if",
"(",
"!",
"is",
"contiguous",
"selection",
"(",
")",
")",
"{",
"return",
"0",
";",
"}",
"if",
"(",
"is",
"flexible",
"array",
"selection",
"(",
")",
")",
"{",
"return",
"integer",
"max",
"value",
";",
"}",
"int",
"row",
"index",
"=",
"selection",
"get",
"field",
"range",
"(",
"0",
")",
"get",
"start",
"(",
")",
"get",
"index",
"(",
")",
"int",
"value",
"(",
")",
";",
"if",
"(",
"row",
"index",
"<",
"get",
"num",
"components",
"(",
")",
")",
"{",
"data",
"type",
"component",
"comp",
"=",
"get",
"component",
"(",
"row",
"index",
")",
";",
"data",
"type",
"dt",
"=",
"comp",
"get",
"data",
"type",
"(",
")",
";",
"int",
"len",
"=",
"dt",
"get",
"length",
"(",
")",
">",
"0",
"?",
"dt",
"get",
"length",
"(",
")",
":",
"comp",
"get",
"length",
"(",
")",
";",
"field",
"range",
"range",
"=",
"get",
"selected",
"range",
"containing",
"(",
"row",
"index",
")",
";",
"boolean",
"single",
"line",
"selection",
"=",
"(",
"get",
"num",
"selected",
"component",
"rows",
"(",
")",
"=",
"=",
"1",
")",
";",
"/",
"/",
"selection",
"exists",
"if",
"(",
"(",
"range",
"!",
"=",
"null",
")",
"&",
"&",
"!",
"single",
"line",
"selection",
")",
"{",
"/",
"/",
"determine",
"the",
"number",
"of",
"bytes",
"int",
"num",
"bytes",
"in",
"range",
"=",
"get",
"num",
"bytes",
"in",
"range",
"(",
"range",
")",
";",
"return",
"num",
"bytes",
"in",
"range",
"/",
"len",
";",
"}",
"/",
"/",
"single",
"line",
"selected",
"/",
"/",
"if",
"edit",
"model",
"is",
"locked",
"then",
"constrain",
"by",
"number",
"of",
"undefined",
"bytes",
"that",
"follow",
"if",
"(",
"!",
"is",
"showing",
"undefined",
"bytes",
"(",
")",
"|",
"|",
"is",
"at",
"end",
"(",
"row",
"index",
")",
"|",
"|",
"only",
"undefineds",
"until",
"end",
"(",
"row",
"index",
"+",
"1",
")",
")",
"{",
"return",
"integer",
"max",
"value",
";",
"}",
"int",
"num",
"bytes",
"=",
"get",
"num",
"undefined",
"bytes",
"at",
"(",
"row",
"index",
"+",
"1",
")",
";",
"return",
"1",
"+",
"(",
"num",
"bytes",
"/",
"len",
")",
";",
"}",
"return",
"0",
";",
"}"
]
|
[
"user",
"'",
"s",
"home",
"scripts",
"directory",
"some",
"tests",
"may",
"override",
"the",
"default",
"using",
"the",
"system",
"utilities",
"user",
"scripts",
"dir",
"system",
"property"
]
| [
"private",
"static",
"string",
"build",
"user",
"scripts",
"directory",
"(",
")",
"{",
"string",
"root",
"=",
"system",
"get",
"property",
"(",
"\"",
"user",
"home",
"\"",
")",
";",
"string",
"override",
"=",
"system",
"get",
"property",
"(",
"ghidra",
"script",
"constants",
"user",
"scripts",
"dir",
"property",
")",
";",
"if",
"(",
"override",
"!",
"=",
"null",
")",
"{",
"msg",
"debug",
"(",
"ghidra",
"script",
"util",
"class",
",",
"\"",
"using",
"ghidra",
"script",
"source",
"directory",
":",
"\"",
"+",
"root",
")",
";",
"root",
"=",
"override",
";",
"}",
"string",
"source",
"path",
"=",
"root",
"+",
"file",
"separator",
"+",
"scripts",
"subdir",
"name",
";",
"return",
"source",
"path",
";",
"}"
]
|
[
"the",
"compression",
"type",
"used",
"with",
"this",
"record"
]
| [
"public",
"compression",
"type",
"compression",
"type",
"(",
")",
"{",
"return",
"compression",
"type",
"for",
"id",
"(",
"buffer",
"get",
"(",
"attributes",
"offset",
")",
"&",
"compression",
"codec",
"mask",
")",
";",
"}"
]
|
[
"identify",
"all",
"partitions",
"which",
"need",
"to",
"be",
"replaced",
"and",
"then",
"delete",
"them",
"the",
"original",
"implementation",
"relied",
"on",
"all",
"the",
"pending",
"commits",
"to",
"be",
"loaded",
"so",
"could",
"simply",
"enumerate",
"them",
"this",
"iteration",
"does",
"not",
"do",
"that",
";",
"it",
"has",
"to",
"reload",
"all",
"the",
"files",
"to",
"build",
"the",
"set",
",",
"after",
"which",
"it",
"initiates",
"the",
"delete",
"process",
"this",
"is",
"done",
"in",
"parallel",
"set",
"<",
"path",
">",
"partitions",
"=",
"pending",
"stream",
"(",
")",
"map",
"(",
"path",
":",
":",
"get",
"parent",
")",
"collect",
"(",
"collectors",
"to",
"collection",
"(",
"sets",
":",
":",
"new",
"linked",
"hash",
"set",
")",
")",
";",
"for",
"(",
"path",
"partition",
"path",
":",
"partitions",
")",
"{",
"log",
"debug",
"(",
"\"",
"{",
"}",
":",
"removing",
"partition",
"path",
"to",
"be",
"replaced",
":",
"\"",
"+",
"get",
"role",
"(",
")",
",",
"partition",
"path",
")",
";",
"fs",
"delete",
"(",
"partition",
"path",
",",
"true",
")",
";",
"}"
]
| [
"private",
"void",
"replace",
"partitions",
"(",
"final",
"job",
"context",
"context",
",",
"final",
"active",
"commit",
"pending",
")",
"throws",
"i",
"o",
"exception",
"{",
"map",
"<",
"path",
",",
"string",
">",
"partitions",
"=",
"new",
"concurrent",
"hash",
"map",
"<",
">",
"(",
")",
";",
"file",
"system",
"source",
"f",
"s",
"=",
"pending",
"get",
"source",
"f",
"s",
"(",
")",
";",
"tasks",
"submitter",
"submitter",
"=",
"build",
"submitter",
"(",
"context",
")",
";",
"try",
"(",
"duration",
"info",
"ignored",
"=",
"new",
"duration",
"info",
"(",
"log",
",",
"\"",
"replacing",
"partitions",
"\"",
")",
")",
"{",
"/",
"/",
"the",
"parent",
"directories",
"are",
"saved",
"to",
"a",
"concurrent",
"hash",
"map",
"/",
"/",
"for",
"a",
"marginal",
"optimisation",
",",
"the",
"previous",
"parent",
"is",
"tracked",
",",
"so",
"/",
"/",
"if",
"a",
"task",
"writes",
"many",
"files",
"to",
"the",
"same",
"dir",
",",
"the",
"synchronized",
"map",
"/",
"/",
"is",
"updated",
"only",
"once",
"tasks",
"foreach",
"(",
"pending",
"get",
"source",
"files",
"(",
")",
")",
"stop",
"on",
"failure",
"(",
")",
"suppress",
"exceptions",
"(",
"false",
")",
"execute",
"with",
"(",
"submitter",
")",
"run",
"(",
"status",
"-",
">",
"{",
"pending",
"set",
"pending",
"set",
"=",
"pending",
"set",
"load",
"(",
"source",
"f",
"s",
",",
"status",
")",
";",
"path",
"last",
"parent",
"=",
"null",
";",
"for",
"(",
"single",
"pending",
"commit",
"commit",
":",
"pending",
"set",
"get",
"commits",
"(",
")",
")",
"{",
"path",
"parent",
"=",
"commit",
"destination",
"path",
"(",
")",
"get",
"parent",
"(",
")",
";",
"if",
"(",
"parent",
"!",
"=",
"null",
"&",
"&",
"!",
"parent",
"equals",
"(",
"last",
"parent",
")",
")",
"{",
"partitions",
"put",
"(",
"parent",
",",
"\"",
"\"",
")",
";",
"last",
"parent",
"=",
"parent",
";",
"}",
"}",
"}",
")",
";",
"}",
"/",
"/",
"now",
"do",
"the",
"deletes",
"file",
"system",
"fs",
"=",
"get",
"dest",
"f",
"s",
"(",
")",
";",
"tasks",
"foreach",
"(",
"partitions",
"key",
"set",
"(",
")",
")",
"stop",
"on",
"failure",
"(",
")",
"suppress",
"exceptions",
"(",
"false",
")",
"execute",
"with",
"(",
"submitter",
")",
"run",
"(",
"partition",
"path",
"-",
">",
"{",
"log",
"debug",
"(",
"\"",
"{",
"}",
":",
"removing",
"partition",
"path",
"to",
"be",
"replaced",
":",
"\"",
"+",
"get",
"role",
"(",
")",
",",
"partition",
"path",
")",
";",
"fs",
"delete",
"(",
"partition",
"path",
",",
"true",
")",
";",
"}",
")",
";",
"}"
]
|
[
"called",
"directly",
"after",
"user",
"configs",
"got",
"parsed",
"(",
"and",
"thus",
"default",
"values",
"got",
"set",
")",
"this",
"allows",
"to",
"change",
"default",
"values",
"for",
"\"",
"secondary",
"defaults",
"\"",
"if",
"required"
]
| [
"protected",
"map",
"<",
"string",
",",
"object",
">",
"post",
"process",
"parsed",
"config",
"(",
"map",
"<",
"string",
",",
"object",
">",
"parsed",
"values",
")",
"{",
"return",
"collections",
"empty",
"map",
"(",
")",
";",
"}"
]
|
[
"finds",
"the",
"child",
"with",
"the",
"specified",
"index",
"and",
"returns",
"it",
"as",
"a",
"char"
]
| [
"public",
"char",
"get",
"char",
"(",
"int",
"index",
")",
"{",
"json",
"value",
"child",
"=",
"get",
"(",
"index",
")",
";",
"if",
"(",
"child",
"=",
"=",
"null",
")",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"indexed",
"value",
"not",
"found",
":",
"\"",
"+",
"name",
")",
";",
"return",
"child",
"as",
"char",
"(",
")",
";",
"}"
]
|
[
"returns",
"the",
"host",
"via",
"{",
"@",
"link",
"inet",
"socket",
"address",
"#",
"get",
"host",
"string",
"}",
"if",
"it",
"is",
"possible",
",",
"i",
"e",
"in",
"jdk",
">",
"=",
"7",
"otherwise",
",",
"return",
"it",
"via",
"{",
"@",
"link",
"inet",
"socket",
"address",
"#",
"get",
"host",
"name",
"}",
"which",
"may",
"incur",
"a",
"dns",
"lookup"
]
| [
"public",
"static",
"string",
"get",
"host",
"(",
"inet",
"socket",
"address",
"addr",
")",
"{",
"try",
"{",
"method",
"get",
"host",
"string",
"method",
"=",
"inet",
"socket",
"address",
"class",
"get",
"method",
"(",
"\"",
"get",
"host",
"string",
"\"",
")",
";",
"return",
"(",
"string",
")",
"get",
"host",
"string",
"method",
"invoke",
"(",
"addr",
")",
";",
"}",
"catch",
"(",
"no",
"such",
"method",
"exception",
"e",
")",
"{",
"/",
"/",
"noop",
"}",
"catch",
"(",
"illegal",
"access",
"exception",
"e",
")",
"{",
"/",
"/",
"noop",
"}",
"catch",
"(",
"invocation",
"target",
"exception",
"e",
")",
"{",
"/",
"/",
"noop",
"}",
"return",
"addr",
"get",
"host",
"name",
"(",
")",
";",
"}"
]
|
[
"important",
"!",
"!",
"!",
"we",
"pass",
"only",
"the",
"partition",
"number",
",",
"because",
"we",
"must",
"make",
"sure",
"we",
"get",
"a",
"fresh",
"partition",
"reference",
"the",
"partition",
"reference",
"used",
"during",
"search",
"for",
"the",
"key",
"may",
"have",
"become",
"invalid",
"during",
"the",
"compaction"
]
| [
"private",
"void",
"insert",
"bucket",
"entry",
"from",
"search",
"(",
"memory",
"segment",
"original",
"bucket",
",",
"memory",
"segment",
"current",
"bucket",
",",
"int",
"original",
"bucket",
"offset",
",",
"int",
"current",
"bucket",
"offset",
",",
"int",
"count",
"in",
"current",
"bucket",
",",
"long",
"original",
"forward",
"pointer",
",",
"int",
"hash",
"code",
",",
"long",
"pointer",
",",
"int",
"partition",
"number",
")",
"throws",
"i",
"o",
"exception",
"{",
"boolean",
"check",
"for",
"resize",
"=",
"false",
";",
"if",
"(",
"count",
"in",
"current",
"bucket",
"<",
"num",
"entries",
"per",
"bucket",
")",
"{",
"/",
"/",
"we",
"are",
"good",
"in",
"our",
"current",
"bucket",
",",
"put",
"the",
"values",
"current",
"bucket",
"put",
"int",
"(",
"current",
"bucket",
"offset",
"+",
"bucket",
"header",
"length",
"+",
"(",
"count",
"in",
"current",
"bucket",
"*",
"hash",
"code",
"len",
")",
",",
"hash",
"code",
")",
";",
"/",
"/",
"hash",
"code",
"current",
"bucket",
"put",
"long",
"(",
"current",
"bucket",
"offset",
"+",
"bucket",
"pointer",
"start",
"offset",
"+",
"(",
"count",
"in",
"current",
"bucket",
"*",
"pointer",
"len",
")",
",",
"pointer",
")",
";",
"/",
"/",
"pointer",
"current",
"bucket",
"put",
"int",
"(",
"current",
"bucket",
"offset",
"+",
"header",
"count",
"offset",
",",
"count",
"in",
"current",
"bucket",
"+",
"1",
")",
";",
"/",
"/",
"update",
"count",
"}",
"else",
"{",
"/",
"/",
"we",
"go",
"to",
"a",
"new",
"overflow",
"bucket",
"final",
"in",
"memory",
"partition",
"<",
"t",
">",
"partition",
"=",
"this",
"partitions",
"get",
"(",
"partition",
"number",
")",
";",
"memory",
"segment",
"overflow",
"seg",
";",
"final",
"int",
"overflow",
"segment",
"num",
";",
"final",
"int",
"overflow",
"bucket",
"offset",
";",
"/",
"/",
"first",
",",
"see",
"if",
"there",
"is",
"space",
"for",
"an",
"overflow",
"bucket",
"remaining",
"in",
"the",
"last",
"overflow",
"/",
"/",
"segment",
"if",
"(",
"partition",
"next",
"overflow",
"bucket",
"=",
"=",
"0",
")",
"{",
"/",
"/",
"no",
"space",
"left",
"in",
"last",
"bucket",
",",
"or",
"no",
"bucket",
"yet",
",",
"so",
"create",
"an",
"overflow",
"segment",
"overflow",
"seg",
"=",
"get",
"next",
"buffer",
"(",
")",
";",
"overflow",
"bucket",
"offset",
"=",
"0",
";",
"overflow",
"segment",
"num",
"=",
"partition",
"num",
"overflow",
"segments",
";",
"/",
"/",
"add",
"the",
"new",
"overflow",
"segment",
"if",
"(",
"partition",
"overflow",
"segments",
"length",
"<",
"=",
"partition",
"num",
"overflow",
"segments",
")",
"{",
"memory",
"segment",
"[",
"]",
"new",
"segs",
"array",
"=",
"new",
"memory",
"segment",
"[",
"partition",
"overflow",
"segments",
"length",
"*",
"2",
"]",
";",
"system",
"arraycopy",
"(",
"partition",
"overflow",
"segments",
",",
"0",
",",
"new",
"segs",
"array",
",",
"0",
",",
"partition",
"overflow",
"segments",
"length",
")",
";",
"partition",
"overflow",
"segments",
"=",
"new",
"segs",
"array",
";",
"}",
"partition",
"overflow",
"segments",
"[",
"partition",
"num",
"overflow",
"segments",
"]",
"=",
"overflow",
"seg",
";",
"partition",
"num",
"overflow",
"segments",
"+",
"+",
";",
"check",
"for",
"resize",
"=",
"true",
";",
"}",
"else",
"{",
"/",
"/",
"there",
"is",
"space",
"in",
"the",
"last",
"overflow",
"segment",
"overflow",
"segment",
"num",
"=",
"partition",
"num",
"overflow",
"segments",
"-",
"1",
";",
"overflow",
"seg",
"=",
"partition",
"overflow",
"segments",
"[",
"overflow",
"segment",
"num",
"]",
";",
"overflow",
"bucket",
"offset",
"=",
"partition",
"next",
"overflow",
"bucket",
"<",
"<",
"num",
"intra",
"bucket",
"bits",
";",
"}",
"/",
"/",
"next",
"overflow",
"bucket",
"is",
"one",
"ahead",
"if",
"the",
"segment",
"is",
"full",
",",
"the",
"next",
"will",
"be",
"at",
"the",
"/",
"/",
"beginning",
"/",
"/",
"of",
"a",
"new",
"segment",
"partition",
"next",
"overflow",
"bucket",
"=",
"(",
"partition",
"next",
"overflow",
"bucket",
"=",
"=",
"this",
"buckets",
"per",
"segment",
"mask",
"?",
"0",
":",
"partition",
"next",
"overflow",
"bucket",
"+",
"1",
")",
";",
"/",
"/",
"insert",
"the",
"new",
"overflow",
"bucket",
"in",
"the",
"chain",
"of",
"buckets",
"/",
"/",
"1",
")",
"set",
"the",
"old",
"forward",
"pointer",
"/",
"/",
"2",
")",
"let",
"the",
"bucket",
"in",
"the",
"main",
"table",
"point",
"to",
"this",
"one",
"overflow",
"seg",
"put",
"long",
"(",
"overflow",
"bucket",
"offset",
"+",
"header",
"forward",
"offset",
",",
"original",
"forward",
"pointer",
")",
";",
"final",
"long",
"pointer",
"to",
"new",
"bucket",
"=",
"(",
"(",
"(",
"long",
")",
"overflow",
"segment",
"num",
")",
"<",
"<",
"32",
")",
"|",
"(",
"(",
"long",
")",
"overflow",
"bucket",
"offset",
")",
";",
"original",
"bucket",
"put",
"long",
"(",
"original",
"bucket",
"offset",
"+",
"header",
"forward",
"offset",
",",
"pointer",
"to",
"new",
"bucket",
")",
";",
"/",
"/",
"finally",
",",
"insert",
"the",
"values",
"into",
"the",
"overflow",
"buckets",
"overflow",
"seg",
"put",
"int",
"(",
"overflow",
"bucket",
"offset",
"+",
"bucket",
"header",
"length",
",",
"hash",
"code",
")",
";",
"/",
"/",
"hash",
"code",
"overflow",
"seg",
"put",
"long",
"(",
"overflow",
"bucket",
"offset",
"+",
"bucket",
"pointer",
"start",
"offset",
",",
"pointer",
")",
";",
"/",
"/",
"pointer",
"/",
"/",
"set",
"the",
"count",
"to",
"one",
"overflow",
"seg",
"put",
"int",
"(",
"overflow",
"bucket",
"offset",
"+",
"header",
"count",
"offset",
",",
"1",
")",
";",
"if",
"(",
"check",
"for",
"resize",
"&",
"&",
"!",
"this",
"is",
"resizing",
")",
"{",
"/",
"/",
"check",
"if",
"we",
"should",
"resize",
"buckets",
"if",
"(",
"this",
"buckets",
"length",
"<",
"=",
"get",
"overflow",
"segment",
"count",
"(",
")",
")",
"{",
"resize",
"hash",
"table",
"(",
")",
";",
"}",
"}",
"}",
"}"
]
|
[
"sets",
"head",
"map"
]
| [
"public",
"rpc",
"message",
"set",
"head",
"map",
"(",
"map",
"<",
"string",
",",
"string",
">",
"head",
"map",
")",
"{",
"this",
"head",
"map",
"=",
"head",
"map",
";",
"return",
"this",
";",
"}"
]
|
[
"get",
"the",
"priority",
"for",
"the",
"option",
"following",
"this",
"one",
"in",
"normal",
",",
"incremental",
"option",
"parsing",
",",
"the",
"returned",
"priority",
"would",
"compare",
"to",
"as",
"after",
"the",
"current",
"one",
"does",
"not",
"increment",
"ancestor",
"priorities"
]
| [
"static",
"option",
"priority",
"next",
"option",
"priority",
"(",
"option",
"priority",
"priority",
")",
"{",
"int",
"last",
"element",
"position",
"=",
"priority",
"priority",
"indices",
"size",
"(",
")",
"-",
"1",
";",
"return",
"new",
"option",
"priority",
"(",
"priority",
"priority",
"category",
",",
"immutable",
"list",
"<",
"integer",
">",
"builder",
"(",
")",
"add",
"all",
"(",
"priority",
"priority",
"indices",
"sub",
"list",
"(",
"0",
",",
"last",
"element",
"position",
")",
")",
"add",
"(",
"priority",
"priority",
"indices",
"get",
"(",
"last",
"element",
"position",
")",
"+",
"1",
")",
"build",
"(",
")",
")",
";",
"}"
]
|
[
"validate",
"the",
"request",
"parameters",
"and",
"throw",
"a",
"<",
"code",
">",
"policy",
"violation",
"exception",
"<",
"code",
">",
"with",
"a",
"suitable",
"error",
"message",
"if",
"the",
"alter",
"configs",
"request",
"parameters",
"for",
"the",
"provided",
"resource",
"do",
"not",
"satisfy",
"this",
"policy",
"clients",
"will",
"receive",
"the",
"policy",
"violation",
"error",
"code",
"along",
"with",
"the",
"exception",
"'",
"s",
"message",
"note",
"that",
"validation",
"failure",
"only",
"affects",
"the",
"relevant",
"resource",
",",
"other",
"resources",
"in",
"the",
"request",
"will",
"still",
"be",
"processed"
]
| [
"void",
"validate",
"(",
"request",
"metadata",
"request",
"metadata",
")",
"throws",
"policy",
"violation",
"exception",
";"
]
|
[
"used",
"in",
"test",
"only"
]
| [
"void",
"set",
"append",
"chunk",
"(",
"final",
"boolean",
"append",
"chunk",
")",
"{",
"get",
"streamer",
"(",
")",
"set",
"append",
"chunk",
"(",
"append",
"chunk",
")",
";",
"}"
]
|
[
"normalizes",
"the",
"up",
"vector",
"by",
"first",
"calculating",
"the",
"right",
"vector",
"via",
"a",
"cross",
"product",
"between",
"direction",
"and",
"up",
",",
"and",
"then",
"recalculating",
"the",
"up",
"vector",
"via",
"a",
"cross",
"product",
"between",
"right",
"and",
"direction"
]
| [
"public",
"void",
"normalize",
"up",
"(",
")",
"{",
"tmp",
"vec",
"set",
"(",
"direction",
")",
"crs",
"(",
"up",
")",
";",
"up",
"set",
"(",
"tmp",
"vec",
")",
"crs",
"(",
"direction",
")",
"nor",
"(",
")",
";",
"}"
]
|
[
"sorts",
"the",
"elements",
"of",
"{",
"@",
"code",
"array",
"}",
"in",
"descending",
"order",
",",
"interpreting",
"them",
"as",
"unsigned",
"32",
"-",
"bit",
"integers"
]
| [
"public",
"static",
"void",
"sort",
"descending",
"(",
"int",
"[",
"]",
"array",
")",
"{",
"check",
"not",
"null",
"(",
"array",
")",
";",
"sort",
"descending",
"(",
"array",
",",
"0",
",",
"array",
"length",
")",
";",
"}"
]
|
[
"decides",
"in",
"current",
"situation",
"whether",
"or",
"not",
"the",
"rpc",
"should",
"retry",
"and",
"if",
"it",
"should",
"retry",
"how",
"long",
"the",
"backoff",
"should",
"be",
"the",
"decision",
"does",
"not",
"take",
"the",
"commitment",
"status",
"into",
"account",
",",
"so",
"caller",
"should",
"check",
"it",
"separately",
"it",
"also",
"updates",
"the",
"throttle",
"it",
"does",
"not",
"change",
"state"
]
| [
"private",
"retry",
"plan",
"make",
"retry",
"decision",
"(",
"status",
"status",
",",
"metadata",
"trailer",
")",
"{",
"if",
"(",
"retry",
"policy",
"=",
"=",
"null",
")",
"{",
"return",
"new",
"retry",
"plan",
"(",
"false",
",",
"0",
")",
";",
"}",
"boolean",
"should",
"retry",
"=",
"false",
";",
"long",
"backoff",
"nanos",
"=",
"0l",
";",
"boolean",
"is",
"retryable",
"status",
"code",
"=",
"retry",
"policy",
"retryable",
"status",
"codes",
"contains",
"(",
"status",
"get",
"code",
"(",
")",
")",
";",
"integer",
"pushback",
"millis",
"=",
"get",
"pushback",
"mills",
"(",
"trailer",
")",
";",
"boolean",
"is",
"throttled",
"=",
"false",
";",
"if",
"(",
"throttle",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"is",
"retryable",
"status",
"code",
"|",
"|",
"(",
"pushback",
"millis",
"!",
"=",
"null",
"&",
"&",
"pushback",
"millis",
"<",
"0",
")",
")",
"{",
"is",
"throttled",
"=",
"!",
"throttle",
"on",
"qualified",
"failure",
"then",
"check",
"is",
"above",
"threshold",
"(",
")",
";",
"}",
"}",
"if",
"(",
"retry",
"policy",
"max",
"attempts",
">",
"substream",
"previous",
"attempt",
"count",
"+",
"1",
"&",
"&",
"!",
"is",
"throttled",
")",
"{",
"if",
"(",
"pushback",
"millis",
"=",
"=",
"null",
")",
"{",
"if",
"(",
"is",
"retryable",
"status",
"code",
")",
"{",
"should",
"retry",
"=",
"true",
";",
"backoff",
"nanos",
"=",
"(",
"long",
")",
"(",
"next",
"backoff",
"interval",
"nanos",
"*",
"random",
"next",
"double",
"(",
")",
")",
";",
"next",
"backoff",
"interval",
"nanos",
"=",
"math",
"min",
"(",
"(",
"long",
")",
"(",
"next",
"backoff",
"interval",
"nanos",
"*",
"retry",
"policy",
"backoff",
"multiplier",
")",
",",
"retry",
"policy",
"max",
"backoff",
"nanos",
")",
";",
"}",
"/",
"/",
"else",
"no",
"retry",
"}",
"else",
"if",
"(",
"pushback",
"millis",
">",
"=",
"0",
")",
"{",
"should",
"retry",
"=",
"true",
";",
"backoff",
"nanos",
"=",
"time",
"unit",
"milliseconds",
"to",
"nanos",
"(",
"pushback",
"millis",
")",
";",
"next",
"backoff",
"interval",
"nanos",
"=",
"retry",
"policy",
"initial",
"backoff",
"nanos",
";",
"}",
"/",
"/",
"else",
"no",
"retry",
"}",
"/",
"/",
"else",
"no",
"retry",
"return",
"new",
"retry",
"plan",
"(",
"should",
"retry",
",",
"backoff",
"nanos",
")",
";",
"}"
]
|
[
"marks",
"this",
"action",
"as",
"one",
"that",
"shares",
"a",
"key",
"binding",
"with",
"other",
"actions",
"in",
"the",
"tool",
"this",
"allows",
"multiple",
"clients",
"to",
"supply",
"actions",
"that",
"use",
"the",
"same",
"key",
"binding",
",",
"each",
"working",
"within",
"its",
"respective",
"action",
"context",
"see",
"{",
"@",
"link",
"key",
"binding",
"type",
"}",
"actions",
"are",
"not",
"shared",
"by",
"default",
";",
"they",
"are",
"{",
"@",
"link",
"key",
"binding",
"type",
"#",
"individual",
"}",
"this",
"means",
"that",
"each",
"action",
"must",
"have",
"its",
"key",
"binding",
"assigned",
"individually"
]
| [
"public",
"b",
"shared",
"key",
"binding",
"(",
")",
"{",
"this",
"key",
"binding",
"type",
"=",
"key",
"binding",
"type",
"shared",
";",
"return",
"self",
"(",
")",
";",
"}"
]
|
[
"validates",
"that",
"multiple",
"checkpoints",
"from",
"different",
"jobs",
"with",
"the",
"same",
"checkpoint",
"id",
"do",
"not",
"interfere",
"with",
"each",
"other"
]
| [
"public",
"void",
"test",
"persist",
"multiple",
"metadata",
"only",
"checkpoints",
"(",
")",
"throws",
"exception",
"{",
"final",
"file",
"system",
"fs",
"=",
"file",
"system",
"get",
"local",
"file",
"system",
"(",
")",
";",
"final",
"path",
"checkpoint",
"dir",
"=",
"new",
"path",
"(",
"tmp",
"new",
"folder",
"(",
")",
"to",
"u",
"r",
"i",
"(",
")",
")",
";",
"final",
"long",
"checkpoint",
"id",
"=",
"177",
";",
"final",
"checkpoint",
"storage",
"access",
"storage",
"1",
"=",
"create",
"checkpoint",
"storage",
"(",
"checkpoint",
"dir",
")",
";",
"storage",
"1",
"initialize",
"base",
"locations",
"(",
")",
";",
"final",
"checkpoint",
"storage",
"access",
"storage",
"2",
"=",
"create",
"checkpoint",
"storage",
"(",
"checkpoint",
"dir",
")",
";",
"storage",
"2",
"initialize",
"base",
"locations",
"(",
")",
";",
"final",
"checkpoint",
"storage",
"location",
"loc",
"1",
"=",
"storage",
"1",
"initialize",
"location",
"for",
"checkpoint",
"(",
"checkpoint",
"id",
")",
";",
"final",
"checkpoint",
"storage",
"location",
"loc",
"2",
"=",
"storage",
"2",
"initialize",
"location",
"for",
"checkpoint",
"(",
"checkpoint",
"id",
")",
";",
"final",
"byte",
"[",
"]",
"data",
"1",
"=",
"{",
"77",
",",
"66",
",",
"55",
",",
"99",
",",
"88",
"}",
";",
"final",
"byte",
"[",
"]",
"data",
"2",
"=",
"{",
"1",
",",
"3",
",",
"2",
",",
"5",
",",
"4",
"}",
";",
"final",
"completed",
"checkpoint",
"storage",
"location",
"completed",
"location",
"1",
";",
"try",
"(",
"checkpoint",
"metadata",
"output",
"stream",
"out",
"=",
"loc",
"1",
"create",
"metadata",
"output",
"stream",
"(",
")",
")",
"{",
"out",
"write",
"(",
"data",
"1",
")",
";",
"completed",
"location",
"1",
"=",
"out",
"close",
"and",
"finalize",
"checkpoint",
"(",
")",
";",
"}",
"final",
"string",
"result",
"1",
"=",
"completed",
"location",
"1",
"get",
"external",
"pointer",
"(",
")",
";",
"final",
"completed",
"checkpoint",
"storage",
"location",
"completed",
"location",
"2",
";",
"try",
"(",
"checkpoint",
"metadata",
"output",
"stream",
"out",
"=",
"loc",
"2",
"create",
"metadata",
"output",
"stream",
"(",
")",
")",
"{",
"out",
"write",
"(",
"data",
"2",
")",
";",
"completed",
"location",
"2",
"=",
"out",
"close",
"and",
"finalize",
"checkpoint",
"(",
")",
";",
"}",
"final",
"string",
"result",
"2",
"=",
"completed",
"location",
"2",
"get",
"external",
"pointer",
"(",
")",
";",
"/",
"/",
"check",
"that",
"this",
"went",
"to",
"a",
"file",
",",
"but",
"in",
"a",
"nested",
"directory",
"structure",
"/",
"/",
"one",
"directory",
"per",
"storage",
"file",
"status",
"[",
"]",
"files",
"=",
"fs",
"list",
"status",
"(",
"checkpoint",
"dir",
")",
";",
"assert",
"equals",
"(",
"2",
",",
"files",
"length",
")",
";",
"/",
"/",
"in",
"each",
"per",
"-",
"storage",
"directory",
",",
"one",
"for",
"the",
"checkpoint",
"file",
"status",
"[",
"]",
"job",
"1",
"files",
"=",
"fs",
"list",
"status",
"(",
"files",
"[",
"0",
"]",
"get",
"path",
"(",
")",
")",
";",
"file",
"status",
"[",
"]",
"job",
"2",
"files",
"=",
"fs",
"list",
"status",
"(",
"files",
"[",
"1",
"]",
"get",
"path",
"(",
")",
")",
";",
"assert",
"true",
"(",
"job",
"1",
"files",
"length",
">",
"=",
"1",
")",
";",
"assert",
"true",
"(",
"job",
"2",
"files",
"length",
">",
"=",
"1",
")",
";",
"assert",
"true",
"(",
"fs",
"exists",
"(",
"new",
"path",
"(",
"result",
"1",
",",
"abstract",
"fs",
"checkpoint",
"storage",
"access",
"metadata",
"file",
"name",
")",
")",
")",
";",
"assert",
"true",
"(",
"fs",
"exists",
"(",
"new",
"path",
"(",
"result",
"2",
",",
"abstract",
"fs",
"checkpoint",
"storage",
"access",
"metadata",
"file",
"name",
")",
")",
")",
";",
"/",
"/",
"check",
"that",
"both",
"storages",
"can",
"resolve",
"each",
"others",
"contents",
"validate",
"contents",
"(",
"storage",
"1",
"resolve",
"checkpoint",
"(",
"result",
"1",
")",
"get",
"metadata",
"handle",
"(",
")",
",",
"data",
"1",
")",
";",
"validate",
"contents",
"(",
"storage",
"1",
"resolve",
"checkpoint",
"(",
"result",
"2",
")",
"get",
"metadata",
"handle",
"(",
")",
",",
"data",
"2",
")",
";",
"validate",
"contents",
"(",
"storage",
"2",
"resolve",
"checkpoint",
"(",
"result",
"1",
")",
"get",
"metadata",
"handle",
"(",
")",
",",
"data",
"1",
")",
";",
"validate",
"contents",
"(",
"storage",
"2",
"resolve",
"checkpoint",
"(",
"result",
"2",
")",
"get",
"metadata",
"handle",
"(",
")",
",",
"data",
"2",
")",
";",
"}"
]
|
[
"will",
"set",
"the",
"image",
"of",
"an",
"image",
"view",
"from",
"a",
"resource",
"id"
]
| [
"public",
"base",
"adapter",
"helper",
"set",
"image",
"resource",
"(",
"int",
"view",
"id",
",",
"int",
"image",
"res",
"id",
")",
"{",
"image",
"view",
"view",
"=",
"retrieve",
"view",
"(",
"view",
"id",
")",
";",
"view",
"set",
"image",
"resource",
"(",
"image",
"res",
"id",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"opens",
"a",
"url",
"with",
"read",
"and",
"connect",
"timeouts"
]
| [
"public",
"u",
"r",
"l",
"connection",
"open",
"connection",
"(",
"url",
"url",
",",
"boolean",
"is",
"spnego",
")",
"throws",
"i",
"o",
"exception",
",",
"authentication",
"exception",
"{",
"if",
"(",
"is",
"spnego",
")",
"{",
"log",
"debug",
"(",
"\"",
"open",
"authenticated",
"u",
"r",
"l",
"connection",
"{",
"}",
"\"",
",",
"url",
")",
";",
"user",
"group",
"information",
"get",
"current",
"user",
"(",
")",
"check",
"t",
"g",
"t",
"and",
"relogin",
"from",
"keytab",
"(",
")",
";",
"final",
"authenticated",
"u",
"r",
"l",
"token",
"auth",
"token",
"=",
"new",
"authenticated",
"u",
"r",
"l",
"token",
"(",
")",
";",
"return",
"new",
"authenticated",
"u",
"r",
"l",
"(",
"new",
"kerberos",
"ugi",
"authenticator",
"(",
")",
",",
"conn",
"configurator",
")",
"open",
"connection",
"(",
"url",
",",
"auth",
"token",
")",
";",
"}",
"else",
"{",
"log",
"debug",
"(",
"\"",
"open",
"url",
"connection",
"\"",
")",
";",
"u",
"r",
"l",
"connection",
"connection",
"=",
"url",
"open",
"connection",
"(",
")",
";",
"if",
"(",
"connection",
"instanceof",
"http",
"u",
"r",
"l",
"connection",
")",
"{",
"conn",
"configurator",
"configure",
"(",
"(",
"http",
"u",
"r",
"l",
"connection",
")",
"connection",
")",
";",
"}",
"return",
"connection",
";",
"}",
"}"
]
|
[
"performs",
"a",
"non",
"-",
"destructive",
"bit",
"-",
"wise",
"\"",
"and",
"\"",
"of",
"this",
"bit",
"field",
"with",
"another",
"one"
]
| [
"public",
"bit",
"field",
"and",
"(",
"bit",
"field",
"other",
")",
"{",
"int",
"size",
"=",
"math",
"min",
"(",
"bytes",
"length",
",",
"other",
"bytes",
"length",
")",
";",
"byte",
"[",
"]",
"result",
"=",
"new",
"byte",
"[",
"size",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"size",
";",
"i",
"+",
"+",
")",
"{",
"result",
"[",
"i",
"]",
"=",
"(",
"byte",
")",
"(",
"bytes",
"[",
"i",
"]",
"&",
"other",
"bytes",
"[",
"i",
"]",
")",
";",
"}",
"return",
"new",
"bit",
"field",
"(",
"result",
")",
";",
"}"
]
|
[
"execute",
"all",
"publishers",
"even",
"one",
"of",
"them",
"throws",
"any",
"exceptions"
]
| [
"public",
"void",
"test",
"freestyle",
"with",
"i",
"o",
"exception",
"publisher",
"(",
")",
"throws",
"exception",
"{",
"free",
"style",
"project",
"p",
"=",
"j",
"create",
"free",
"style",
"project",
"(",
")",
";",
"p",
"get",
"publishers",
"list",
"(",
")",
"add",
"(",
"new",
"true",
"false",
"publisher",
"(",
"true",
")",
")",
";",
"/",
"/",
"noop",
"p",
"get",
"publishers",
"list",
"(",
")",
"add",
"(",
"new",
"i",
"o",
"exception",
"publisher",
"(",
")",
")",
";",
"/",
"/",
"fail",
"with",
"i",
"o",
"exception",
"p",
"get",
"publishers",
"list",
"(",
")",
"add",
"(",
"new",
"result",
"writer",
"publisher",
"(",
"\"",
"result",
"txt",
"\"",
")",
")",
";",
"/",
"/",
"catch",
"result",
"to",
"file",
"final",
"artifact",
"archiver",
"artifact",
"archiver",
"=",
"new",
"artifact",
"archiver",
"(",
"\"",
"result",
"txt",
"\"",
")",
";",
"artifact",
"archiver",
"set",
"only",
"if",
"successful",
"(",
"false",
")",
";",
"p",
"get",
"publishers",
"list",
"(",
")",
"add",
"(",
"artifact",
"archiver",
")",
";",
"/",
"/",
"transfer",
"file",
"to",
"build",
"dir",
"free",
"style",
"build",
"b",
"=",
"p",
"schedule",
"build",
"2",
"(",
"0",
")",
"get",
"(",
")",
";",
"assert",
"equals",
"(",
"\"",
"build",
"must",
"fail",
",",
"because",
"we",
"used",
"false",
"publisher",
"\"",
",",
"b",
"get",
"result",
"(",
")",
",",
"result",
"failure",
")",
";",
"j",
"assert",
"log",
"contains",
"(",
"\"",
"\\",
"tat",
"hudson",
"model",
"utils",
"i",
"o",
"exception",
"publisher",
"\"",
",",
"b",
")",
";",
"/",
"/",
"log",
"must",
"contain",
"stacktrace",
"j",
"assert",
"log",
"contains",
"(",
"\"",
"threw",
"i",
"o",
"exception",
"from",
"publisher",
"!",
"\"",
",",
"b",
")",
";",
"/",
"/",
"log",
"must",
"contain",
"exact",
"error",
"message",
"file",
"file",
"=",
"new",
"file",
"(",
"b",
"get",
"artifacts",
"dir",
"(",
")",
",",
"\"",
"result",
"txt",
"\"",
")",
";",
"assert",
"true",
"(",
"\"",
"artifact",
"archiver",
"is",
"executed",
"even",
"prior",
"publisher",
"fails",
"\"",
",",
"file",
"exists",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"third",
"publisher",
"must",
"see",
"failure",
"status",
"\"",
",",
"file",
"utils",
"read",
"file",
"to",
"string",
"(",
"file",
")",
",",
"result",
"failure",
"to",
"string",
"(",
")",
")",
";",
"}"
]
|
[
"return",
"step",
"bytes",
",",
"taking",
"into",
"account",
"possible",
"escaped",
"symbol",
"offset"
]
| [
"public",
"byte",
"[",
"]",
"get",
"bytes",
"(",
")",
"{",
"return",
"fragment",
"get",
"bytes",
"(",
"position",
",",
"end",
")",
";",
"}"
]
|
[
"build",
"the",
"request",
"mapping",
"info"
]
| [
"request",
"mapping",
"info",
"build",
"(",
")",
";"
]
|
[
"reads",
"ints",
"from",
"the",
"current",
"position",
"into",
"the",
"specified",
"int",
"array",
",",
"starting",
"from",
"the",
"specified",
"offset",
",",
"and",
"increases",
"the",
"position",
"by",
"the",
"number",
"of",
"ints",
"read"
]
| [
"public",
"int",
"buffer",
"get",
"(",
"int",
"[",
"]",
"dest",
",",
"int",
"off",
",",
"int",
"len",
")",
"{",
"int",
"length",
"=",
"dest",
"length",
";",
"if",
"(",
"off",
"<",
"0",
"|",
"|",
"len",
"<",
"0",
"|",
"|",
"(",
"long",
")",
"len",
"+",
"(",
"long",
")",
"off",
">",
"length",
")",
"{",
"throw",
"new",
"index",
"out",
"of",
"bounds",
"exception",
"(",
")",
";",
"}",
"if",
"(",
"len",
">",
"remaining",
"(",
")",
")",
"{",
"throw",
"new",
"buffer",
"underflow",
"exception",
"(",
")",
";",
"}",
"for",
"(",
"int",
"i",
"=",
"off",
";",
"i",
"<",
"off",
"+",
"len",
";",
"i",
"+",
"+",
")",
"{",
"dest",
"[",
"i",
"]",
"=",
"get",
"(",
")",
";",
"}",
"return",
"this",
";",
"}"
]
|
[
"reads",
"the",
"entire",
"file",
"into",
"the",
"byte",
"array",
"the",
"byte",
"array",
"must",
"be",
"big",
"enough",
"to",
"hold",
"the",
"file",
"'",
"s",
"data"
]
| [
"public",
"int",
"read",
"bytes",
"(",
"byte",
"[",
"]",
"bytes",
",",
"int",
"offset",
",",
"int",
"size",
")",
"{",
"input",
"stream",
"input",
"=",
"read",
"(",
")",
";",
"int",
"position",
"=",
"0",
";",
"try",
"{",
"while",
"(",
"true",
")",
"{",
"int",
"count",
"=",
"input",
"read",
"(",
"bytes",
",",
"offset",
"+",
"position",
",",
"size",
"-",
"position",
")",
";",
"if",
"(",
"count",
"<",
"=",
"0",
")",
"break",
";",
"position",
"+",
"=",
"count",
";",
"}",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ex",
")",
"{",
"throw",
"new",
"gdx",
"runtime",
"exception",
"(",
"\"",
"error",
"reading",
"file",
":",
"\"",
"+",
"this",
",",
"ex",
")",
";",
"}",
"finally",
"{",
"stream",
"utils",
"close",
"quietly",
"(",
"input",
")",
";",
"}",
"return",
"position",
"-",
"offset",
";",
"}"
]
|
[
"creates",
"a",
"32",
"bit",
"program",
"builder",
"that",
"can",
"be",
"used",
"for",
"testing"
]
| [
"protected",
"program",
"builder",
"build",
"3",
"2",
"bit",
"x",
"8",
"6",
"(",
")",
"throws",
"exception",
"{",
"program",
"builder",
"builder",
"=",
"new",
"program",
"builder",
"(",
"\"",
"test",
"3",
"2",
"bit",
"x",
"8",
"6",
"\"",
",",
"program",
"builder",
"x86",
",",
"\"",
"windows",
"\"",
",",
"null",
")",
";",
"set",
"exec",
"format",
"and",
"compiler",
"(",
"builder",
")",
";",
"set",
"image",
"base",
"(",
"builder",
",",
"0x",
"0",
"1",
"0",
"0",
"0",
"0",
"0",
"0",
"l",
")",
";",
"builder",
"create",
"memory",
"(",
"\"",
"text",
"\"",
",",
"\"",
"0x",
"0",
"1",
"0",
"0",
"1",
"0",
"0",
"0",
"\"",
",",
"0x",
"2",
"0",
"0",
"0",
")",
";",
"builder",
"create",
"memory",
"(",
"\"",
"rdata",
"\"",
",",
"\"",
"0x",
"0",
"1",
"0",
"0",
"3",
"0",
"0",
"0",
"\"",
",",
"0x",
"2",
"0",
"0",
"0",
")",
";",
"builder",
"create",
"memory",
"(",
"\"",
"data",
"\"",
",",
"\"",
"0x",
"0",
"1",
"0",
"0",
"5",
"0",
"0",
"0",
"\"",
",",
"0x",
"2",
"0",
"0",
"0",
")",
";",
"setup",
"d",
"t",
"m",
"service",
"(",
"builder",
"get",
"program",
"(",
")",
")",
";",
"setup",
"dummy",
"3",
"2",
"type",
"info",
"(",
"builder",
")",
";",
"return",
"builder",
";",
"}"
]
|
[
"to",
"test",
"enum",
"parameters",
"to",
"test",
"enum",
"parameters"
]
| [
"void",
"test",
"enum",
"parameters",
"(",
"@",
"param",
"(",
"\"",
"enum",
"header",
"string",
"array",
"\"",
")",
"list",
"<",
"string",
">",
"enum",
"header",
"string",
"array",
",",
"@",
"param",
"(",
"\"",
"enum",
"header",
"string",
"\"",
")",
"string",
"enum",
"header",
"string",
",",
"@",
"param",
"(",
"\"",
"enum",
"query",
"string",
"array",
"\"",
")",
"list",
"<",
"string",
">",
"enum",
"query",
"string",
"array",
",",
"@",
"param",
"(",
"\"",
"enum",
"query",
"string",
"\"",
")",
"string",
"enum",
"query",
"string",
",",
"@",
"param",
"(",
"\"",
"enum",
"query",
"integer",
"\"",
")",
"integer",
"enum",
"query",
"integer",
",",
"@",
"param",
"(",
"\"",
"enum",
"query",
"double",
"\"",
")",
"double",
"enum",
"query",
"double",
",",
"@",
"param",
"(",
"\"",
"enum",
"form",
"string",
"array",
"\"",
")",
"list",
"<",
"string",
">",
"enum",
"form",
"string",
"array",
",",
"@",
"param",
"(",
"\"",
"enum",
"form",
"string",
"\"",
")",
"string",
"enum",
"form",
"string",
")",
";"
]
|
[
"encodes",
"a",
"byte",
"[",
"]",
"containing",
"binary",
"data",
",",
"into",
"a",
"string",
"containing",
"characters",
"in",
"the",
"appropriate",
"alphabet",
"uses",
"utf8",
"encoding"
]
| [
"public",
"string",
"encode",
"as",
"string",
"(",
"final",
"byte",
"[",
"]",
"p",
"array",
")",
"{",
"return",
"string",
"utils",
"new",
"string",
"utf",
"8",
"(",
"encode",
"(",
"p",
"array",
")",
")",
";",
"}"
]
|
[
"set",
"a",
"value",
"resolver",
"for",
"embedded",
"placeholders",
"and",
"expressions"
]
| [
"public",
"void",
"set",
"embedded",
"value",
"resolver",
"(",
"@",
"nullable",
"string",
"value",
"resolver",
"embedded",
"value",
"resolver",
")",
"{",
"this",
"embedded",
"value",
"resolver",
"=",
"embedded",
"value",
"resolver",
";",
"}"
]
|
[
"c",
"a",
"ses",
"the",
"busy",
"field",
"from",
"0",
"to",
"1",
"to",
"acquire",
"lock"
]
| [
"final",
"boolean",
"cas",
"busy",
"(",
")",
"{",
"return",
"unsafe",
"compare",
"and",
"swap",
"int",
"(",
"this",
",",
"busy",
"offset",
",",
"0",
",",
"1",
")",
";",
"}"
]
|
[
"gets",
"cached",
"principal",
"attributes"
]
| [
"protected",
"map",
"<",
"string",
",",
"list",
"<",
"object",
">",
">",
"get",
"cached",
"principal",
"attributes",
"(",
"final",
"principal",
"principal",
",",
"final",
"registered",
"service",
"registered",
"service",
")",
"{",
"try",
"{",
"val",
"cache",
"=",
"get",
"cache",
"instance",
"from",
"application",
"context",
"(",
")",
";",
"return",
"cache",
"get",
"cached",
"attributes",
"for",
"(",
"registered",
"service",
",",
"this",
",",
"principal",
")",
";",
"}",
"catch",
"(",
"final",
"exception",
"e",
")",
"{",
"logging",
"utils",
"error",
"(",
"logger",
",",
"e",
")",
";",
"}",
"return",
"new",
"hash",
"map",
"<",
">",
"(",
"0",
")",
";",
"}"
]
|
[
"set",
"the",
"name",
"of",
"this",
"schema"
]
| [
"public",
"schema",
"builder",
"name",
"(",
"string",
"name",
")",
"{",
"check",
"can",
"set",
"(",
"name",
"field",
",",
"this",
"name",
",",
"name",
")",
";",
"this",
"name",
"=",
"name",
";",
"return",
"this",
";",
"}"
]
|
[
"enables",
"checkpointing",
"for",
"the",
"streaming",
"job",
"the",
"distributed",
"state",
"of",
"the",
"streaming",
"dataflow",
"will",
"be",
"periodically",
"snapshotted",
"in",
"case",
"of",
"a",
"failure",
",",
"the",
"streaming",
"dataflow",
"will",
"be",
"restarted",
"from",
"the",
"latest",
"completed",
"checkpoint",
"the",
"job",
"draws",
"checkpoints",
"periodically",
",",
"in",
"the",
"given",
"interval",
"the",
"state",
"will",
"be",
"stored",
"in",
"the",
"configured",
"state",
"backend",
"note",
":",
"checkpointing",
"iterative",
"streaming",
"dataflows",
"in",
"not",
"properly",
"supported",
"at",
"the",
"moment",
"if",
"the",
"\"",
"force",
"\"",
"parameter",
"is",
"set",
"to",
"true",
",",
"the",
"system",
"will",
"execute",
"the",
"job",
"nonetheless"
]
| [
"public",
"stream",
"execution",
"environment",
"enable",
"checkpointing",
"(",
"long",
"interval",
",",
"checkpointing",
"mode",
"mode",
",",
"boolean",
"force",
")",
"{",
"checkpoint",
"cfg",
"set",
"checkpointing",
"mode",
"(",
"mode",
")",
";",
"checkpoint",
"cfg",
"set",
"checkpoint",
"interval",
"(",
"interval",
")",
";",
"checkpoint",
"cfg",
"set",
"force",
"checkpointing",
"(",
"force",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"find",
"pet",
"by",
"id",
"returns",
"a",
"single",
"pet"
]
| [
"public",
"void",
"get",
"pet",
"by",
"id",
"test",
"(",
")",
"throws",
"exception",
"{",
"long",
"pet",
"id",
"=",
"null",
";",
"response",
"entity",
"<",
"pet",
">",
"response",
"=",
"api",
"get",
"pet",
"by",
"id",
"(",
"pet",
"id",
",",
"accept",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
]
|
[
"get",
"peer",
"rpc",
"versions"
]
| [
"public",
"rpc",
"protocol",
"versions",
"get",
"peer",
"rpc",
"versions",
"(",
")",
"{",
"return",
"context",
"get",
"peer",
"rpc",
"versions",
"(",
")",
";",
"}"
]
|
[
"get",
"the",
"instance",
"io",
"statistics"
]
| [
"public",
"i",
"o",
"statistics",
"store",
"get",
"i",
"o",
"statistics",
"(",
")",
"{",
"return",
"instance",
"i",
"o",
"statistics",
";",
"}"
]
|
[
"asynchronously",
"get",
"cluster",
"health",
"using",
"the",
"cluster",
"health",
"api",
"see",
"<",
"a",
"href",
"=",
"\"",
"https",
":",
"www",
"elastic",
"coguideenelasticsearchreferencecurrentcluster",
"-",
"health",
"html",
"\"",
">",
"cluster",
"health",
"api",
"on",
"elastic",
"co",
"if",
"timeout",
"occurred",
",",
"{",
"@",
"link",
"cluster",
"health",
"response",
"}",
"will",
"have",
"is",
"timed",
"out",
"(",
")",
"=",
"=",
"true",
"and",
"status",
"(",
")",
"=",
"=",
"rest",
"status",
"request",
"timeout"
]
| [
"public",
"cancellable",
"health",
"async",
"(",
"cluster",
"health",
"request",
"health",
"request",
",",
"request",
"options",
"options",
",",
"action",
"listener",
"<",
"cluster",
"health",
"response",
">",
"listener",
")",
"{",
"return",
"rest",
"high",
"level",
"client",
"perform",
"request",
"async",
"and",
"parse",
"entity",
"(",
"health",
"request",
",",
"cluster",
"request",
"converters",
":",
":",
"cluster",
"health",
",",
"options",
",",
"cluster",
"health",
"response",
":",
":",
"from",
"x",
"content",
",",
"listener",
",",
"singleton",
"(",
"rest",
"status",
"request",
"timeout",
"get",
"status",
"(",
")",
")",
")",
";",
"}"
]
|
[
"{",
"@",
"inherit",
"doc",
"}"
]
| [
"public",
"type",
"get",
"type",
"(",
")",
"{",
"return",
"type",
"double",
";",
"}"
]
|
[
"get",
"the",
"value",
"of",
"the",
"<",
"code",
">",
"name",
"<",
"code",
">",
"property",
"as",
"a",
"<",
"code",
">",
"boolean",
"<",
"code",
">",
"if",
"no",
"such",
"property",
"is",
"specified",
",",
"or",
"if",
"the",
"specified",
"value",
"is",
"not",
"a",
"valid",
"<",
"code",
">",
"boolean",
"<",
"code",
">",
",",
"then",
"<",
"code",
">",
"default",
"value",
"<",
"code",
">",
"is",
"returned"
]
| [
"public",
"boolean",
"get",
"boolean",
"(",
"string",
"name",
",",
"boolean",
"default",
"value",
")",
"{",
"string",
"value",
"string",
"=",
"get",
"trimmed",
"(",
"name",
")",
";",
"if",
"(",
"null",
"=",
"=",
"value",
"string",
"|",
"|",
"value",
"string",
"is",
"empty",
"(",
")",
")",
"{",
"return",
"default",
"value",
";",
"}",
"if",
"(",
"string",
"utils",
"equals",
"ignore",
"case",
"(",
"\"",
"true",
"\"",
",",
"value",
"string",
")",
")",
"return",
"true",
";",
"else",
"if",
"(",
"string",
"utils",
"equals",
"ignore",
"case",
"(",
"\"",
"false",
"\"",
",",
"value",
"string",
")",
")",
"return",
"false",
";",
"else",
"return",
"default",
"value",
";",
"}"
]
|
[
"returns",
"the",
"enum",
"instance",
"that",
"corresponds",
"to",
"the",
"specified",
"ordinal",
"value"
]
| [
"public",
"t",
"get",
"enum",
"by",
"ordinal",
"(",
"int",
"ordinal",
")",
"{",
"return",
"values",
"[",
"ordinal",
"]",
";",
"}"
]
|
[
"try",
"to",
"process",
"previously",
"queued",
"message",
"this",
"should",
"only",
"be",
"called",
"from",
"the",
"event",
"loop",
"thread"
]
| [
"void",
"process",
"queued",
"buffer",
"(",
")",
"{",
"check",
"is",
"in",
"event",
"loop",
"(",
"\"",
"process",
"queued",
"buffer",
"\"",
")",
";",
"if",
"(",
"queued",
"buffer",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"log",
"is",
"trace",
"enabled",
"(",
")",
")",
"{",
"log",
"trace",
"(",
"\"",
"processing",
"queue",
"0x",
"{",
"}",
"queued",
"buffer",
"{",
"}",
"\"",
",",
"long",
"to",
"hex",
"string",
"(",
"session",
"id",
")",
",",
"byte",
"buf",
"util",
"hex",
"dump",
"(",
"queued",
"buffer",
")",
")",
";",
"}",
"receive",
"message",
"(",
"queued",
"buffer",
")",
";",
"if",
"(",
"closing",
"channel",
")",
"{",
"/",
"/",
"close",
"(",
")",
"could",
"have",
"been",
"called",
"if",
"receive",
"message",
"(",
")",
"failed",
"log",
"debug",
"(",
"\"",
"processed",
"queue",
"-",
"channel",
"closed",
",",
"dropping",
"remaining",
"bytes",
"\"",
")",
";",
"}",
"else",
"if",
"(",
"!",
"queued",
"buffer",
"is",
"readable",
"(",
")",
")",
"{",
"log",
"debug",
"(",
"\"",
"processed",
"queue",
"-",
"no",
"bytes",
"remaining",
"\"",
")",
";",
"release",
"queued",
"buffer",
"(",
")",
";",
"}",
"else",
"{",
"log",
"debug",
"(",
"\"",
"processed",
"queue",
"-",
"bytes",
"remaining",
"\"",
")",
";",
"/",
"/",
"try",
"to",
"reduce",
"memory",
"consumption",
"by",
"freeing",
"up",
"buffer",
"space",
"/",
"/",
"which",
"is",
"no",
"longer",
"needed",
"queued",
"buffer",
"discard",
"read",
"components",
"(",
")",
";",
"}",
"}",
"else",
"{",
"log",
"debug",
"(",
"\"",
"queue",
"empty",
"\"",
")",
";",
"}",
"}"
]
|
[
"test",
"command",
"-",
"set",
"storage",
"type",
"quota",
"with",
"wrong",
"arguments"
]
| [
"public",
"void",
"test",
"wrong",
"arguments",
"when",
"set",
"storage",
"type",
"quota",
"(",
")",
"throws",
"exception",
"{",
"string",
"src",
"=",
"\"",
"/",
"type",
"-",
"quota",
"mounttable",
"\"",
";",
"/",
"/",
"verify",
"wrong",
"arguments",
"system",
"set",
"err",
"(",
"new",
"print",
"stream",
"(",
"err",
")",
")",
";",
"string",
"[",
"]",
"argv",
"=",
"new",
"string",
"[",
"]",
"{",
"\"",
"-",
"set",
"storage",
"type",
"quota",
"\"",
",",
"src",
",",
"\"",
"check",
"\"",
",",
"\"",
"c",
"2",
"\"",
",",
"\"",
"c",
"3",
"\"",
"}",
";",
"tool",
"runner",
"run",
"(",
"admin",
",",
"argv",
")",
";",
"assert",
"true",
"(",
"err",
"to",
"string",
"(",
")",
"contains",
"(",
"\"",
"invalid",
"argument",
":",
"check",
"\"",
")",
")",
";",
"}"
]
|
[
"add",
"an",
"attribute",
"with",
"the",
"given",
"name",
"and",
"value"
]
| [
"builder",
"attribute",
"(",
"string",
"name",
",",
"object",
"value",
")",
";"
]
|
[
"finds",
"pets",
"by",
"status",
"multiple",
"status",
"values",
"can",
"be",
"provided",
"with",
"comma",
"separated",
"strings"
]
| [
"public",
"void",
"find",
"pets",
"by",
"status",
"test",
"(",
")",
"throws",
"api",
"exception",
"{",
"/",
"/",
"list",
"<",
"string",
">",
"status",
"=",
"null",
";",
"/",
"/",
"list",
"<",
"pet",
">",
"response",
"=",
"api",
"find",
"pets",
"by",
"status",
"(",
"status",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
]
|
[
"asserts",
"that",
"if",
"the",
"directory",
"{",
"@",
"code",
"changed",
"path",
"string",
"}",
"changes",
",",
"then",
"the",
"file",
"value",
"corresponding",
"to",
"{",
"@",
"code",
"path",
"string",
"}",
"will",
"change",
"returns",
"the",
"paths",
"of",
"all",
"files",
"seen"
]
| [
"private",
"set",
"<",
"rooted",
"path",
">",
"assert",
"value",
"changes",
"if",
"contents",
"of",
"directory",
"changes",
"(",
"string",
"changed",
"path",
"string",
",",
"boolean",
"changes",
",",
"string",
"path",
"string",
")",
"throws",
"exception",
"{",
"return",
"assert",
"changes",
"if",
"changes",
"(",
"changed",
"path",
"string",
",",
"false",
",",
"changes",
",",
"path",
"string",
")",
";",
"}"
]
|
[
"return",
"the",
"serializable",
"in",
"cache"
]
| [
"public",
"object",
"get",
"serializable",
"(",
"@",
"non",
"null",
"final",
"string",
"key",
")",
"{",
"return",
"get",
"serializable",
"(",
"key",
",",
"null",
")",
";",
"}"
]
|
[
"return",
"the",
"fit",
"time",
"span"
]
| [
"public",
"static",
"string",
"get",
"fit",
"time",
"span",
"(",
"final",
"string",
"time",
"1",
",",
"final",
"string",
"time",
"2",
",",
"@",
"non",
"null",
"final",
"date",
"format",
"format",
",",
"final",
"int",
"precision",
")",
"{",
"long",
"delta",
"=",
"string",
"2",
"millis",
"(",
"time",
"1",
",",
"format",
")",
"-",
"string",
"2",
"millis",
"(",
"time",
"2",
",",
"format",
")",
";",
"return",
"millis",
"2",
"fit",
"time",
"span",
"(",
"delta",
",",
"precision",
")",
";",
"}"
]
|
[
"iterate",
"all",
"source",
"'",
"s",
"blocks",
"to",
"remove",
"moved",
"ones"
]
| [
"private",
"void",
"remove",
"moved",
"blocks",
"(",
")",
"{",
"for",
"(",
"iterator",
"<",
"d",
"block",
">",
"i",
"=",
"get",
"block",
"iterator",
"(",
")",
";",
"i",
"has",
"next",
"(",
")",
";",
")",
"{",
"if",
"(",
"moved",
"blocks",
"contains",
"(",
"i",
"next",
"(",
")",
"get",
"block",
"(",
")",
")",
")",
"{",
"i",
"remove",
"(",
")",
";",
"}",
"}",
"}"
]
|
[
"saves",
"a",
"jar",
"without",
"the",
"manifest"
]
| [
"public",
"static",
"void",
"save",
"as",
"jar",
"(",
"array",
"list",
"<",
"class",
"node",
">",
"node",
"list",
",",
"string",
"path",
")",
"{",
"try",
"{",
"jar",
"output",
"stream",
"out",
"=",
"new",
"jar",
"output",
"stream",
"(",
"new",
"file",
"output",
"stream",
"(",
"path",
")",
")",
";",
"array",
"list",
"<",
"string",
">",
"no",
"dupe",
"=",
"new",
"array",
"list",
"<",
"string",
">",
"(",
")",
";",
"for",
"(",
"class",
"node",
"cn",
":",
"node",
"list",
")",
"{",
"class",
"writer",
"cw",
"=",
"new",
"class",
"writer",
"(",
"0",
")",
";",
"cn",
"accept",
"(",
"cw",
")",
";",
"string",
"name",
"=",
"cn",
"name",
"+",
"\"",
"class",
"\"",
";",
"if",
"(",
"!",
"no",
"dupe",
"contains",
"(",
"name",
")",
")",
"{",
"no",
"dupe",
"add",
"(",
"name",
")",
";",
"out",
"put",
"next",
"entry",
"(",
"new",
"zip",
"entry",
"(",
"name",
")",
")",
";",
"out",
"write",
"(",
"cw",
"to",
"byte",
"array",
"(",
")",
")",
";",
"out",
"close",
"entry",
"(",
")",
";",
"}",
"}",
"for",
"(",
"file",
"container",
"container",
":",
"bytecode",
"viewer",
"files",
")",
"for",
"(",
"entry",
"<",
"string",
",",
"byte",
"[",
"]",
">",
"entry",
":",
"container",
"files",
"entry",
"set",
"(",
")",
")",
"{",
"string",
"filename",
"=",
"entry",
"get",
"key",
"(",
")",
";",
"if",
"(",
"!",
"filename",
"starts",
"with",
"(",
"\"",
"meta",
"-",
"inf",
"\"",
")",
")",
"{",
"if",
"(",
"!",
"no",
"dupe",
"contains",
"(",
"filename",
")",
")",
"{",
"no",
"dupe",
"add",
"(",
"filename",
")",
";",
"out",
"put",
"next",
"entry",
"(",
"new",
"zip",
"entry",
"(",
"filename",
")",
")",
";",
"out",
"write",
"(",
"entry",
"get",
"value",
"(",
")",
")",
";",
"out",
"close",
"entry",
"(",
")",
";",
"}",
"}",
"}",
"no",
"dupe",
"clear",
"(",
")",
";",
"out",
"close",
"(",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"new",
"the",
"bytecode",
"club",
"bytecodeviewer",
"api",
"exception",
"u",
"i",
"(",
"e",
")",
";",
"}",
"}"
]
|
[
"add",
"a",
"job",
"to",
"this",
"jobs",
"'",
"dependency",
"list",
"dependent",
"jobs",
"can",
"only",
"be",
"added",
"while",
"a",
"job",
"is",
"waiting",
"to",
"run",
",",
"not",
"during",
"or",
"afterwards"
]
| [
"public",
"synchronized",
"boolean",
"add",
"depending",
"job",
"(",
"controlled",
"job",
"depending",
"job",
")",
"{",
"if",
"(",
"this",
"state",
"=",
"=",
"state",
"waiting",
")",
"{",
"/",
"/",
"only",
"allowed",
"to",
"add",
"jobs",
"when",
"waiting",
"if",
"(",
"this",
"depending",
"jobs",
"=",
"=",
"null",
")",
"{",
"this",
"depending",
"jobs",
"=",
"new",
"array",
"list",
"<",
"controlled",
"job",
">",
"(",
")",
";",
"}",
"return",
"this",
"depending",
"jobs",
"add",
"(",
"depending",
"job",
")",
";",
"}",
"else",
"{",
"return",
"false",
";",
"}",
"}"
]
|
[
"configures",
"the",
"setting"
]
| [
"void",
"configure",
"(",
"string",
"key",
",",
"@",
"nullable",
"string",
"value",
")",
"{",
"switch",
"(",
"key",
")",
"{",
"case",
"\"",
"initial",
"capacity",
"\"",
":",
"initial",
"capacity",
"(",
"key",
",",
"value",
")",
";",
"return",
";",
"case",
"\"",
"maximum",
"size",
"\"",
":",
"maximum",
"size",
"(",
"key",
",",
"value",
")",
";",
"return",
";",
"case",
"\"",
"maximum",
"weight",
"\"",
":",
"maximum",
"weight",
"(",
"key",
",",
"value",
")",
";",
"return",
";",
"case",
"\"",
"weak",
"keys",
"\"",
":",
"weak",
"keys",
"(",
"value",
")",
";",
"return",
";",
"case",
"\"",
"weak",
"values",
"\"",
":",
"value",
"strength",
"(",
"key",
",",
"value",
",",
"strength",
"weak",
")",
";",
"return",
";",
"case",
"\"",
"soft",
"values",
"\"",
":",
"value",
"strength",
"(",
"key",
",",
"value",
",",
"strength",
"soft",
")",
";",
"return",
";",
"case",
"\"",
"expire",
"after",
"access",
"\"",
":",
"expire",
"after",
"access",
"(",
"key",
",",
"value",
")",
";",
"return",
";",
"case",
"\"",
"expire",
"after",
"write",
"\"",
":",
"expire",
"after",
"write",
"(",
"key",
",",
"value",
")",
";",
"return",
";",
"case",
"\"",
"refresh",
"after",
"write",
"\"",
":",
"refresh",
"after",
"write",
"(",
"key",
",",
"value",
")",
";",
"return",
";",
"case",
"\"",
"record",
"stats",
"\"",
":",
"record",
"stats",
"(",
"value",
")",
";",
"return",
";",
"default",
":",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"unknown",
"key",
"\"",
"+",
"key",
")",
";",
"}",
"}"
]
|
[
"returns",
"a",
"new",
"immutable",
"array",
"containing",
"the",
"values",
"in",
"the",
"specified",
"range",
"<",
"b",
">",
"performance",
"note",
":",
"<",
"b",
">",
"the",
"returned",
"array",
"has",
"the",
"same",
"full",
"memory",
"footprint",
"as",
"this",
"one",
"does",
"(",
"no",
"actual",
"copying",
"is",
"performed",
")",
"to",
"reduce",
"memory",
"usage",
",",
"use",
"{",
"@",
"code",
"sub",
"array",
"(",
"start",
",",
"end",
")",
"trimmed",
"(",
")",
"}"
]
| [
"public",
"immutable",
"long",
"array",
"sub",
"array",
"(",
"int",
"start",
"index",
",",
"int",
"end",
"index",
")",
"{",
"preconditions",
"check",
"position",
"indexes",
"(",
"start",
"index",
",",
"end",
"index",
",",
"length",
"(",
")",
")",
";",
"return",
"start",
"index",
"=",
"=",
"end",
"index",
"?",
"empty",
":",
"new",
"immutable",
"long",
"array",
"(",
"array",
",",
"start",
"+",
"start",
"index",
",",
"start",
"+",
"end",
"index",
")",
";",
"}"
]
|
[
"sends",
"response",
"headers",
"to",
"the",
"remote",
"end",
"point"
]
| [
"void",
"write",
"headers",
"(",
"metadata",
"headers",
")",
";"
]
|
[
"remove",
"the",
"{",
"@",
"linkplain",
"application",
"context",
"application",
"context",
"}",
"for",
"the",
"supplied",
"{",
"@",
"link",
"merged",
"context",
"configuration",
"}",
"from",
"the",
"{",
"@",
"code",
"context",
"cache",
"}",
"and",
"{",
"@",
"linkplain",
"configurable",
"application",
"context",
"#",
"close",
"(",
")",
"close",
"}",
"it",
"if",
"it",
"is",
"an",
"instance",
"of",
"{",
"@",
"link",
"configurable",
"application",
"context",
"}",
"the",
"semantics",
"of",
"the",
"supplied",
"{",
"@",
"code",
"hierarchy",
"mode",
"}",
"must",
"be",
"honored",
"when",
"removing",
"the",
"context",
"from",
"the",
"cache",
"see",
"the",
"javadoc",
"for",
"{",
"@",
"link",
"hierarchy",
"mode",
"}",
"for",
"details",
"generally",
"speaking",
",",
"this",
"method",
"should",
"only",
"be",
"called",
"if",
"the",
"state",
"of",
"a",
"singleton",
"bean",
"has",
"been",
"changed",
"(",
"potentially",
"affecting",
"future",
"interaction",
"with",
"the",
"context",
")",
"or",
"if",
"the",
"context",
"needs",
"to",
"be",
"prematurely",
"removed",
"from",
"the",
"cache"
]
| [
"void",
"close",
"context",
"(",
"merged",
"context",
"configuration",
"merged",
"context",
"configuration",
",",
"@",
"nullable",
"hierarchy",
"mode",
"hierarchy",
"mode",
")",
";"
]
|
[
"return",
"the",
"name",
"of",
"the",
"task",
"to",
"be",
"configured"
]
| [
"public",
"string",
"get",
"name",
"(",
")",
"{",
"return",
"scope",
"get",
"task",
"name",
"(",
"\"",
"merge",
"\"",
",",
"\"",
"so",
"lib",
"\"",
")",
";",
"}"
]
|
[
"sets",
"a",
"new",
"drawable",
"for",
"the",
"image",
"the",
"image",
"'",
"s",
"pref",
"size",
"is",
"the",
"drawable",
"'",
"s",
"min",
"size",
"if",
"using",
"the",
"image",
"actor",
"'",
"s",
"size",
"rather",
"than",
"the",
"pref",
"size",
",",
"{",
"@",
"link",
"#",
"pack",
"(",
")",
"}",
"can",
"be",
"used",
"to",
"size",
"the",
"image",
"to",
"its",
"pref",
"size"
]
| [
"public",
"void",
"set",
"drawable",
"(",
"@",
"null",
"drawable",
"drawable",
")",
"{",
"if",
"(",
"this",
"drawable",
"=",
"=",
"drawable",
")",
"return",
";",
"if",
"(",
"drawable",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"get",
"pref",
"width",
"(",
")",
"!",
"=",
"drawable",
"get",
"min",
"width",
"(",
")",
"|",
"|",
"get",
"pref",
"height",
"(",
")",
"!",
"=",
"drawable",
"get",
"min",
"height",
"(",
")",
")",
"invalidate",
"hierarchy",
"(",
")",
";",
"}",
"else",
"invalidate",
"hierarchy",
"(",
")",
";",
"this",
"drawable",
"=",
"drawable",
";",
"}"
]
|
[
"expanded",
"query",
"looking",
"for",
"alternatives"
]
| [
"public",
"static",
"finder",
"expanded",
"finder",
"(",
"string",
"queries",
")",
"{",
"var",
"finder",
"=",
"ident",
"sum",
"(",
")",
";",
"for",
"(",
"string",
"query",
":",
"queries",
")",
"{",
"finder",
"=",
"finder",
"or",
"(",
"finder",
"contains",
"(",
"query",
")",
")",
";",
"}",
"return",
"finder",
";",
"}"
]
|
[
"this",
"is",
"called",
"when",
"all",
"the",
"declared",
"dependencies",
"exist",
"it",
"may",
"request",
"new",
"dependencies"
]
| [
"sky",
"value",
"compute",
"(",
"map",
"<",
"sky",
"key",
",",
"sky",
"value",
">",
"deps",
",",
"sky",
"function",
"environment",
"env",
")",
"throws",
"interrupted",
"exception",
";"
]
|
[
"increment",
"a",
"counter",
"by",
"one",
"no",
"-",
"op",
"if",
"the",
"counter",
"is",
"unknown"
]
| [
"default",
"long",
"increment",
"counter",
"(",
"string",
"key",
")",
"{",
"return",
"increment",
"counter",
"(",
"key",
",",
"1",
")",
";",
"}"
]
|
[
"get",
"anytype",
"1"
]
| [
"public",
"object",
"get",
"anytype",
"1",
"(",
")",
"{",
"return",
"anytype",
"1",
";",
"}"
]
|
[
"stores",
"the",
"next",
"result",
"set",
"row",
"in",
"a",
"tuple"
]
| [
"public",
"row",
"next",
"record",
"(",
"row",
"reuse",
")",
"throws",
"i",
"o",
"exception",
"{",
"try",
"{",
"if",
"(",
"!",
"has",
"next",
")",
"{",
"return",
"null",
";",
"}",
"for",
"(",
"int",
"pos",
"=",
"0",
";",
"pos",
"<",
"reuse",
"get",
"arity",
"(",
")",
";",
"pos",
"+",
"+",
")",
"{",
"reuse",
"set",
"field",
"(",
"pos",
",",
"result",
"set",
"get",
"object",
"(",
"pos",
"+",
"1",
")",
")",
";",
"}",
"/",
"/",
"update",
"has",
"next",
"after",
"we",
"'",
"ve",
"read",
"the",
"record",
"has",
"next",
"=",
"result",
"set",
"next",
"(",
")",
";",
"return",
"reuse",
";",
"}",
"catch",
"(",
"s",
"q",
"l",
"exception",
"se",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"couldn",
"'",
"t",
"read",
"data",
"-",
"\"",
"+",
"se",
"get",
"message",
"(",
")",
",",
"se",
")",
";",
"}",
"catch",
"(",
"null",
"pointer",
"exception",
"npe",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"couldn",
"'",
"t",
"access",
"result",
"set",
"\"",
",",
"npe",
")",
";",
"}",
"}"
]
|
[
"set",
"the",
"jar",
"by",
"finding",
"where",
"a",
"given",
"class",
"came",
"from"
]
| [
"public",
"void",
"set",
"jar",
"by",
"class",
"(",
"class",
"<",
"?",
">",
"cls",
")",
"{",
"ensure",
"state",
"(",
"job",
"state",
"define",
")",
";",
"conf",
"set",
"jar",
"by",
"class",
"(",
"cls",
")",
";",
"}"
]
|
[
"clear",
"the",
"current",
"cache",
"of",
"diffs",
"and",
"statistics"
]
| [
"private",
"void",
"clear",
"(",
")",
"{",
"synchronized",
"(",
"diffs",
")",
"{",
"diffs",
"clear",
"(",
")",
";",
"}",
"stats",
"clear",
"(",
")",
";",
"}"
]
|
[
"configure",
"a",
"handler",
"for",
"customizing",
"or",
"handling",
"stomp",
"error",
"frames",
"to",
"clients"
]
| [
"web",
"mvc",
"stomp",
"endpoint",
"registry",
"set",
"error",
"handler",
"(",
"stomp",
"sub",
"protocol",
"error",
"handler",
"error",
"handler",
")",
";"
]
|
[
"returns",
"the",
"number",
"of",
"microseconds",
"during",
"cool",
"down",
"that",
"we",
"have",
"to",
"wait",
"to",
"get",
"a",
"new",
"permit"
]
| [
"abstract",
"double",
"cool",
"down",
"interval",
"micros",
"(",
")",
";"
]
|
[
"get",
"photo",
"urls"
]
| [
"public",
"set",
"<",
"string",
">",
"get",
"photo",
"urls",
"(",
")",
"{",
"return",
"photo",
"urls",
";",
"}"
]
|
[
"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",
"\"",
")",
";",
"}"
]
|
[
"increment",
"the",
"initial",
"window",
"size",
"for",
"this",
"stream"
]
| [
"void",
"increment",
"initial",
"stream",
"window",
"(",
"int",
"delta",
")",
";"
]
|
[
"generate",
"an",
"input",
"stream",
"from",
"the",
"bytes",
"that",
"have",
"been",
"appended",
"to",
"the",
"buffer",
"the",
"buffer",
"is",
"not",
"copied"
]
| [
"public",
"byte",
"array",
"input",
"stream",
"get",
"input",
"stream",
"(",
")",
"{",
"return",
"new",
"byte",
"array",
"input",
"stream",
"(",
"value",
",",
"0",
",",
"count",
")",
";",
"}"
]
|
[
"test",
"resilience",
"to",
"empty",
"snapshots"
]
| [
"public",
"void",
"test",
"restore",
"with",
"empty",
"snap",
"files",
"(",
")",
"throws",
"exception",
"{",
"run",
"test",
"(",
"true",
",",
"false",
")",
";",
"}"
]
|
[
"get",
"rpc",
"xid"
]
| [
"private",
"string",
"get",
"rpc",
"xid",
"(",
")",
"{",
"string",
"rpc",
"xid",
"=",
"rpc",
"context",
"get",
"context",
"(",
")",
"get",
"attachment",
"(",
"root",
"context",
"key",
"xid",
")",
";",
"if",
"(",
"rpc",
"xid",
"=",
"=",
"null",
")",
"{",
"rpc",
"xid",
"=",
"rpc",
"context",
"get",
"context",
"(",
")",
"get",
"attachment",
"(",
"root",
"context",
"key",
"xid",
"to",
"lower",
"case",
"(",
")",
")",
";",
"}",
"return",
"rpc",
"xid",
";",
"}"
]
|
[
"resets",
"variables",
"maintaining",
"the",
"sum",
"to",
"zero",
"this",
"method",
"may",
"be",
"a",
"useful",
"alternative",
"to",
"creating",
"a",
"new",
"adder",
",",
"but",
"is",
"only",
"effective",
"if",
"there",
"are",
"no",
"concurrent",
"updates",
"because",
"this",
"method",
"is",
"intrinsically",
"racy",
",",
"it",
"should",
"only",
"be",
"used",
"when",
"it",
"is",
"known",
"that",
"no",
"threads",
"are",
"concurrently",
"updating"
]
| [
"public",
"void",
"reset",
"(",
")",
"{",
"internal",
"reset",
"(",
"0l",
")",
";",
"}"
]
|
[
"make",
"the",
"table"
]
| [
"public",
"boolean",
"make",
"table",
"(",
"program",
"program",
",",
"int",
"start",
",",
"int",
"end",
",",
"boolean",
"create",
"index",
",",
"boolean",
"auto",
"label",
")",
"{",
"if",
"(",
"end",
">",
"table",
"elements",
"length",
"-",
"1",
")",
"{",
"end",
"=",
"table",
"elements",
"length",
"-",
"1",
";",
"}",
"if",
"(",
"end",
"<",
"start",
")",
"{",
"end",
"=",
"start",
";",
"}",
"int",
"len",
"=",
"end",
"-",
"start",
"+",
"1",
";",
"address",
"current",
"address",
"=",
"top",
"address",
"add",
"wrap",
"(",
"start",
"*",
"addr",
"size",
")",
";",
"/",
"/",
"make",
"sure",
"this",
"pointer",
"is",
"in",
"the",
"data",
"type",
"manager",
"/",
"/",
"since",
"we",
"are",
"going",
"to",
"use",
"it",
"a",
"lot",
"data",
"type",
"adt",
";",
"/",
"/",
"todo",
":",
"do",
"i",
"need",
"to",
"do",
"something",
"special",
"for",
"the",
"3",
"byte",
"pointers",
"or",
"will",
"it",
"know",
"/",
"/",
"how",
"to",
"make",
"it",
"automatically",
"?",
"data",
"type",
"manager",
"dtm",
"=",
"program",
"get",
"data",
"type",
"manager",
"(",
")",
";",
"if",
"(",
"shifted",
"addr",
")",
"{",
"adt",
"=",
"shifted",
"address",
"data",
"type",
"data",
"type",
";",
"}",
"else",
"if",
"(",
"addr",
"size",
"=",
"=",
"program",
"get",
"default",
"pointer",
"size",
"(",
")",
")",
"{",
"adt",
"=",
"new",
"pointer",
"data",
"type",
"(",
"data",
"type",
"default",
",",
"dtm",
")",
";",
"}",
"else",
"{",
"adt",
"=",
"new",
"pointer",
"data",
"type",
"(",
"data",
"type",
"default",
",",
"addr",
"size",
",",
"dtm",
")",
";",
"}",
"adt",
"=",
"dtm",
"resolve",
"(",
"adt",
",",
"null",
")",
";",
"address",
"new",
"address",
"=",
"current",
"address",
";",
"/",
"/",
"check",
"to",
"make",
"sure",
"there",
"is",
"no",
"existing",
"things",
"overlapping",
"the",
"table",
"or",
"the",
"index",
"listing",
"listing",
"=",
"program",
"get",
"listing",
"(",
")",
";",
"int",
"total",
"len",
"=",
"(",
"len",
"*",
"addr",
"size",
"+",
"skip",
"amount",
")",
";",
"if",
"(",
"create",
"index",
")",
"{",
"total",
"len",
"+",
"=",
"get",
"index",
"length",
"(",
")",
";",
"}",
"if",
"(",
"!",
"listing",
"is",
"undefined",
"(",
"current",
"address",
",",
"current",
"address",
"add",
"wrap",
"(",
"total",
"len",
"-",
"1",
")",
")",
")",
"{",
"for",
"(",
"int",
"k",
"=",
"0",
";",
"k",
"<",
"total",
"len",
";",
"k",
"+",
"+",
")",
"{",
"data",
"data",
"=",
"listing",
"get",
"data",
"containing",
"(",
"current",
"address",
"add",
"wrap",
"(",
"k",
")",
")",
";",
"if",
"(",
"data",
"=",
"=",
"null",
"|",
"|",
"(",
"!",
"(",
"data",
"is",
"pointer",
"(",
")",
"|",
"|",
"data",
"get",
"data",
"type",
"(",
")",
"instanceof",
"undefined",
")",
"&",
"&",
"data",
"is",
"defined",
"(",
")",
")",
")",
"{",
"return",
"false",
";",
"}",
"}",
"}",
"/",
"/",
"make",
"the",
"pointers",
"/",
"/",
"todo",
":",
"add",
"in",
"the",
"skip",
"length",
"for",
"(",
"int",
"j",
"=",
"0",
";",
"j",
"<",
"len",
";",
"j",
"+",
"+",
")",
"{",
"try",
"{",
"/",
"/",
"make",
"the",
"data",
"an",
"address",
"pointer",
"data",
"utilities",
"create",
"data",
"(",
"program",
",",
"new",
"address",
",",
"adt",
",",
"adt",
"get",
"length",
"(",
")",
",",
"false",
",",
"data",
"utilities",
"clear",
"data",
"mode",
"clear",
"all",
"undefined",
"conflict",
"data",
")",
";",
"}",
"catch",
"(",
"code",
"unit",
"insertion",
"exception",
"exc",
")",
"{",
"}",
"new",
"address",
"=",
"new",
"address",
"add",
"wrap",
"(",
"addr",
"size",
"+",
"skip",
"amount",
")",
";",
"}",
"if",
"(",
"create",
"index",
")",
"{",
"create",
"table",
"index",
"(",
"program",
")",
";",
"}",
"if",
"(",
"auto",
"label",
")",
"{",
"set",
"labels",
"(",
"program",
",",
"current",
"address",
",",
"len",
",",
"start",
")",
";",
"}",
"return",
"true",
";",
"}"
]
|
[
"gets",
"a",
"16",
"-",
"bit",
"short",
"integer",
"at",
"the",
"current",
"{",
"@",
"code",
"reader",
"index",
"}",
"in",
"the",
"little",
"endian",
"byte",
"order",
"and",
"increases",
"the",
"{",
"@",
"code",
"reader",
"index",
"}",
"by",
"{",
"@",
"code",
"2",
"}",
"in",
"this",
"buffer"
]
| [
"public",
"abstract",
"short",
"read",
"short",
"l",
"e",
"(",
")",
";"
]
|
[
"gets",
"the",
"name",
"of",
"the",
"ldap",
"attribute",
"that",
"stores",
"the",
"registered",
"service",
"integer",
"unique",
"identifier"
]
| [
"string",
"get",
"id",
"attribute",
"(",
")",
";"
]
|
[
"returns",
"the",
"full",
"hash",
"size"
]
| [
"public",
"short",
"get",
"code",
"unit",
"size",
"(",
")",
"{",
"return",
"record",
"get",
"short",
"value",
"(",
"code",
"unit",
"size",
"col",
")",
";",
"}"
]
|
[
"find",
"the",
"fields",
"constant",
"that",
"matches",
"field",
"id",
",",
"or",
"null",
"if",
"its",
"not",
"found"
]
| [
"public",
"static",
"fields",
"find",
"by",
"thrift",
"id",
"(",
"int",
"field",
"id",
")",
"{",
"switch",
"(",
"field",
"id",
")",
"{",
"case",
"1",
":",
"/",
"/",
"serialized",
"java",
"return",
"serialized",
"java",
";",
"case",
"2",
":",
"/",
"/",
"shell",
"return",
"shell",
";",
"case",
"3",
":",
"/",
"/",
"java",
"object",
"return",
"java",
"object",
";",
"default",
":",
"return",
"null",
";",
"}",
"}"
]
|
[
"get",
"the",
"appropriate",
"kerberos",
"auth",
"module",
"for",
"jaas",
"entries",
"for",
"this",
"jvm"
]
| [
"public",
"static",
"string",
"get",
"kerberos",
"auth",
"module",
"for",
"j",
"v",
"m",
"(",
")",
"{",
"if",
"(",
"system",
"get",
"property",
"(",
"\"",
"java",
"vendor",
"\"",
")",
"contains",
"(",
"\"",
"ibm",
"\"",
")",
")",
"{",
"return",
"\"",
"com",
"ibm",
"security",
"auth",
"module",
"krb",
"5",
"login",
"module",
"\"",
";",
"}",
"else",
"{",
"return",
"\"",
"com",
"sun",
"security",
"auth",
"module",
"krb",
"5",
"login",
"module",
"\"",
";",
"}",
"}"
]
|
[
"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",
"\"",
")",
";",
"}"
]
|
[
"terminates",
"the",
"cas",
"sso",
"session",
"by",
"destroying",
"the",
"tgt",
"(",
"if",
"any",
")",
"and",
"removing",
"cookies",
"related",
"to",
"the",
"sso",
"session"
]
| [
"protected",
"event",
"terminate",
"(",
"final",
"request",
"context",
"context",
")",
"{",
"val",
"request",
"=",
"web",
"utils",
"get",
"http",
"servlet",
"request",
"from",
"external",
"webflow",
"context",
"(",
"context",
")",
";",
"val",
"response",
"=",
"web",
"utils",
"get",
"http",
"servlet",
"response",
"from",
"external",
"webflow",
"context",
"(",
"context",
")",
";",
"val",
"tgt",
"id",
"=",
"get",
"ticket",
"granting",
"ticket",
"(",
"context",
")",
";",
"if",
"(",
"string",
"utils",
"is",
"not",
"blank",
"(",
"tgt",
"id",
")",
")",
"{",
"logger",
"trace",
"(",
"\"",
"destroying",
"sso",
"session",
"linked",
"to",
"ticket",
"-",
"granting",
"ticket",
"[",
"{",
"}",
"]",
"\"",
",",
"tgt",
"id",
")",
";",
"val",
"logout",
"requests",
"=",
"initiate",
"single",
"logout",
"(",
"tgt",
"id",
",",
"request",
",",
"response",
")",
";",
"web",
"utils",
"put",
"logout",
"requests",
"(",
"context",
",",
"logout",
"requests",
")",
";",
"}",
"logger",
"trace",
"(",
"\"",
"removing",
"cas",
"cookies",
"\"",
")",
";",
"this",
"ticket",
"granting",
"ticket",
"cookie",
"generator",
"remove",
"cookie",
"(",
"response",
")",
";",
"this",
"warn",
"cookie",
"generator",
"remove",
"cookie",
"(",
"response",
")",
";",
"destroy",
"application",
"session",
"(",
"request",
",",
"response",
")",
";",
"logger",
"debug",
"(",
"\"",
"terminated",
"all",
"cas",
"sessions",
"successfully",
"\"",
")",
";",
"if",
"(",
"string",
"utils",
"is",
"not",
"blank",
"(",
"logout",
"properties",
"get",
"redirect",
"url",
"(",
")",
")",
")",
"{",
"web",
"utils",
"put",
"logout",
"redirect",
"url",
"(",
"context",
",",
"logout",
"properties",
"get",
"redirect",
"url",
"(",
")",
")",
";",
"return",
"this",
"event",
"factory",
"support",
"event",
"(",
"this",
",",
"cas",
"webflow",
"constants",
"state",
"id",
"redirect",
")",
";",
"}",
"return",
"this",
"event",
"factory",
"support",
"success",
"(",
"this",
")",
";",
"}"
]
|
[
"generates",
"a",
"string",
"from",
"a",
"list",
"of",
"{",
"@",
"link",
"sequence",
"item",
"}",
"s",
"with",
"each",
"missing",
"{",
"@",
"link",
"sequence",
"item",
"}",
"replaces",
"by",
"a",
"\"",
"\""
]
| [
"public",
"static",
"string",
"get",
"ditted",
"string",
"(",
"list",
"<",
"sequence",
"item",
">",
"item",
"list",
",",
"int",
"total",
"length",
")",
"{",
"string",
"builder",
"sb",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"int",
"symbols",
"written",
"=",
"0",
";",
"for",
"(",
"sequence",
"item",
"current",
"item",
":",
"item",
"list",
")",
"{",
"if",
"(",
"current",
"item",
"get",
"index",
"(",
")",
"<",
"symbols",
"written",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"item",
"list",
"must",
"be",
"in",
"ascending",
"order",
"of",
"item",
"index",
"\"",
")",
";",
"}",
"while",
"(",
"current",
"item",
"get",
"index",
"(",
")",
">",
"symbols",
"written",
")",
"{",
"sb",
"append",
"(",
"\"",
"\"",
")",
";",
"/",
"/",
"add",
"a",
"dit",
"symbols",
"written",
"+",
"+",
";",
"}",
"sb",
"append",
"(",
"current",
"item",
"get",
"symbol",
"(",
")",
")",
";",
"symbols",
"written",
"+",
"+",
";",
"}",
"if",
"(",
"symbols",
"written",
">",
"total",
"length",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"mismatch",
"between",
"item",
"list",
"and",
"total",
"length",
"\"",
")",
";",
"}",
"while",
"(",
"symbols",
"written",
"<",
"total",
"length",
")",
"{",
"sb",
"append",
"(",
"\"",
"\"",
")",
";",
"symbols",
"written",
"+",
"+",
";",
"}",
"return",
"sb",
"to",
"string",
"(",
")",
";",
"}"
]
|
[
"test",
"the",
"property",
"'",
"tags",
"'"
]
| [
"public",
"void",
"tags",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"tags",
"}"
]
|
[
"return",
"true",
"if",
"the",
"given",
"character",
"is",
"mapped",
"to",
"a",
"supported",
"entity",
"reference"
]
| [
"public",
"boolean",
"is",
"mapped",
"to",
"reference",
"(",
"char",
"character",
")",
"{",
"return",
"is",
"mapped",
"to",
"reference",
"(",
"character",
",",
"web",
"utils",
"default",
"character",
"encoding",
")",
";",
"}"
]
|
[
"shutdown",
"the",
"system"
]
| [
"public",
"void",
"do",
"exit",
"(",
"stapler",
"request",
"req",
",",
"stapler",
"response",
"rsp",
")",
"throws",
"i",
"o",
"exception",
"{",
"check",
"permission",
"(",
"administer",
")",
";",
"if",
"(",
"rsp",
"!",
"=",
"null",
")",
"{",
"rsp",
"set",
"status",
"(",
"http",
"servlet",
"response",
"sc",
"ok",
")",
";",
"rsp",
"set",
"content",
"type",
"(",
"\"",
"text",
"/",
"plain",
"\"",
")",
";",
"try",
"(",
"print",
"writer",
"w",
"=",
"rsp",
"get",
"writer",
"(",
")",
")",
"{",
"w",
"println",
"(",
"\"",
"shutting",
"down",
"\"",
")",
";",
"}",
"}",
"new",
"thread",
"(",
"\"",
"exit",
"thread",
"\"",
")",
"{",
"@",
"override",
"@",
"suppress",
"f",
"b",
"warnings",
"(",
"value",
"=",
"\"",
"dm",
"exit",
"\"",
",",
"justification",
"=",
"\"",
"exit",
"is",
"really",
"intended",
"\"",
")",
"public",
"void",
"run",
"(",
")",
"{",
"try",
"(",
"a",
"c",
"l",
"context",
"ctx",
"=",
"acl",
"as",
"2",
"(",
"acl",
"system2",
")",
")",
"{",
"logger",
"info",
"(",
"string",
"format",
"(",
"\"",
"shutting",
"down",
"vm",
"as",
"requested",
"by",
"%",
"s",
"from",
"%",
"s",
"\"",
",",
"get",
"authentication",
"2",
"(",
")",
"get",
"name",
"(",
")",
",",
"req",
"!",
"=",
"null",
"?",
"req",
"get",
"remote",
"addr",
"(",
")",
":",
"\"",
"?",
"?",
"?",
"\"",
")",
")",
";",
"clean",
"up",
"(",
")",
";",
"system",
"exit",
"(",
"0",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"logger",
"log",
"(",
"level",
"warning",
",",
"\"",
"failed",
"to",
"shut",
"down",
"jenkins",
"\"",
",",
"e",
")",
";",
"}",
"}",
"}",
"start",
"(",
")",
";",
"}"
]
|
[
"poll",
"all",
"tasks",
"from",
"the",
"task",
"queue",
"and",
"run",
"them",
"via",
"{",
"@",
"link",
"runnable",
"#",
"run",
"(",
")",
"}",
"method",
"this",
"method",
"stops",
"running",
"the",
"tasks",
"in",
"the",
"task",
"queue",
"and",
"returns",
"if",
"it",
"ran",
"longer",
"than",
"{",
"@",
"code",
"timeout",
"nanos",
"}"
]
| [
"protected",
"boolean",
"run",
"all",
"tasks",
"(",
"long",
"timeout",
"nanos",
")",
"{",
"fetch",
"from",
"scheduled",
"task",
"queue",
"(",
")",
";",
"runnable",
"task",
"=",
"poll",
"task",
"(",
")",
";",
"if",
"(",
"task",
"=",
"=",
"null",
")",
"{",
"after",
"running",
"all",
"tasks",
"(",
")",
";",
"return",
"false",
";",
"}",
"final",
"long",
"deadline",
"=",
"timeout",
"nanos",
">",
"0",
"?",
"scheduled",
"future",
"task",
"nano",
"time",
"(",
")",
"+",
"timeout",
"nanos",
":",
"0",
";",
"long",
"run",
"tasks",
"=",
"0",
";",
"long",
"last",
"execution",
"time",
";",
"for",
"(",
";",
";",
")",
"{",
"safe",
"execute",
"(",
"task",
")",
";",
"run",
"tasks",
"+",
"+",
";",
"/",
"/",
"check",
"timeout",
"every",
"64",
"tasks",
"because",
"nano",
"time",
"(",
")",
"is",
"relatively",
"expensive",
"/",
"/",
"xxx",
":",
"hard",
"-",
"coded",
"value",
"-",
"will",
"make",
"it",
"configurable",
"if",
"it",
"is",
"really",
"a",
"problem",
"if",
"(",
"(",
"run",
"tasks",
"&",
"0x",
"3",
"f",
")",
"=",
"=",
"0",
")",
"{",
"last",
"execution",
"time",
"=",
"scheduled",
"future",
"task",
"nano",
"time",
"(",
")",
";",
"if",
"(",
"last",
"execution",
"time",
">",
"=",
"deadline",
")",
"{",
"break",
";",
"}",
"}",
"task",
"=",
"poll",
"task",
"(",
")",
";",
"if",
"(",
"task",
"=",
"=",
"null",
")",
"{",
"last",
"execution",
"time",
"=",
"scheduled",
"future",
"task",
"nano",
"time",
"(",
")",
";",
"break",
";",
"}",
"}",
"after",
"running",
"all",
"tasks",
"(",
")",
";",
"this",
"last",
"execution",
"time",
"=",
"last",
"execution",
"time",
";",
"return",
"true",
";",
"}"
]
|
[
"returns",
"a",
"view",
"of",
"a",
"{",
"@",
"code",
"list",
"multimap",
"}",
"whose",
"values",
"are",
"derived",
"from",
"the",
"original",
"multimap",
"'",
"s",
"entries",
"in",
"contrast",
"to",
"{",
"@",
"link",
"#",
"transform",
"values",
"(",
"list",
"multimap",
",",
"function",
")",
"}",
",",
"this",
"method",
"'",
"s",
"entry",
"-",
"transformation",
"logic",
"may",
"depend",
"on",
"the",
"key",
"as",
"well",
"as",
"the",
"value",
"all",
"other",
"properties",
"of",
"the",
"transformed",
"multimap",
",",
"such",
"as",
"iteration",
"order",
",",
"are",
"left",
"intact",
"for",
"example",
",",
"the",
"code",
":",
"{",
"@",
"code",
"multimap",
"<",
"string",
",",
"integer",
">",
"multimap",
"=",
"immutable",
"multimap",
"of",
"(",
"\"",
"a",
"\"",
",",
"1",
",",
"\"",
"a",
"\"",
",",
"4",
",",
"\"",
"b",
"\"",
",",
"6",
")",
";",
"entry",
"transformer",
"<",
"string",
",",
"integer",
",",
"string",
">",
"transformer",
"=",
"new",
"entry",
"transformer",
"<",
"string",
",",
"integer",
",",
"string",
">",
"(",
")",
"{",
"public",
"string",
"transform",
"entry",
"(",
"string",
"key",
",",
"integer",
"value",
")",
"{",
"return",
"key",
"+",
"value",
";",
"}",
"}",
";",
"multimap",
"<",
"string",
",",
"string",
">",
"transformed",
"=",
"multimaps",
"transform",
"entries",
"(",
"multimap",
",",
"transformer",
")",
";",
"system",
"out",
"println",
"(",
"transformed",
")",
";",
"}",
"prints",
"{",
"@",
"code",
"{",
"\"",
"a",
"\"",
"=",
"[",
"\"",
"a",
"1",
"\"",
",",
"\"",
"a",
"4",
"\"",
"]",
",",
"\"",
"b",
"\"",
"=",
"[",
"\"",
"b",
"6",
"\"",
"]",
"}",
"}",
"changes",
"in",
"the",
"underlying",
"multimap",
"are",
"reflected",
"in",
"this",
"view",
"conversely",
",",
"this",
"view",
"supports",
"removal",
"operations",
",",
"and",
"these",
"are",
"reflected",
"in",
"the",
"underlying",
"multimap",
"it",
"'",
"s",
"acceptable",
"for",
"the",
"underlying",
"multimap",
"to",
"contain",
"null",
"keys",
"and",
"null",
"values",
"provided",
"that",
"the",
"transformer",
"is",
"capable",
"of",
"accepting",
"null",
"inputs",
"the",
"transformed",
"multimap",
"might",
"contain",
"null",
"values",
"if",
"the",
"transformer",
"sometimes",
"gives",
"a",
"null",
"result",
"the",
"returned",
"multimap",
"is",
"not",
"thread",
"-",
"safe",
"or",
"serializable",
",",
"even",
"if",
"the",
"underlying",
"multimap",
"is",
"the",
"transformer",
"is",
"applied",
"lazily",
",",
"invoked",
"when",
"needed",
"this",
"is",
"necessary",
"for",
"the",
"returned",
"multimap",
"to",
"be",
"a",
"view",
",",
"but",
"it",
"means",
"that",
"the",
"transformer",
"will",
"be",
"applied",
"many",
"times",
"for",
"bulk",
"operations",
"like",
"{",
"@",
"link",
"multimap",
"#",
"contains",
"value",
"}",
"and",
"{",
"@",
"link",
"object",
"#",
"to",
"string",
"}",
"for",
"this",
"to",
"perform",
"well",
",",
"{",
"@",
"code",
"transformer",
"}",
"should",
"be",
"fast",
"to",
"avoid",
"lazy",
"evaluation",
"when",
"the",
"returned",
"multimap",
"doesn",
"'",
"t",
"need",
"to",
"be",
"a",
"view",
",",
"copy",
"the",
"returned",
"multimap",
"into",
"a",
"new",
"multimap",
"of",
"your",
"choosing",
"<",
"b",
">",
"warning",
":",
"<",
"b",
">",
"this",
"method",
"assumes",
"that",
"for",
"any",
"instance",
"{",
"@",
"code",
"k",
"}",
"of",
"{",
"@",
"code",
"entry",
"transformer",
"}",
"key",
"type",
"{",
"@",
"code",
"k",
"}",
",",
"{",
"@",
"code",
"k",
"equals",
"(",
"k",
"2",
")",
"}",
"implies",
"that",
"{",
"@",
"code",
"k",
"2",
"}",
"is",
"also",
"of",
"type",
"{",
"@",
"code",
"k",
"}",
"using",
"an",
"{",
"@",
"code",
"entry",
"transformer",
"}",
"key",
"type",
"for",
"which",
"this",
"may",
"not",
"hold",
",",
"such",
"as",
"{",
"@",
"code",
"array",
"list",
"}",
",",
"may",
"risk",
"a",
"{",
"@",
"code",
"class",
"cast",
"exception",
"}",
"when",
"calling",
"methods",
"on",
"the",
"transformed",
"multimap"
]
| [
"public",
"static",
"<",
"k",
",",
"v1",
",",
"v2",
">",
"list",
"multimap",
"<",
"k",
",",
"v2",
">",
"transform",
"entries",
"(",
"list",
"multimap",
"<",
"k",
",",
"v1",
">",
"from",
"map",
",",
"entry",
"transformer",
"<",
"?",
"super",
"k",
",",
"?",
"super",
"v1",
",",
"v2",
">",
"transformer",
")",
"{",
"return",
"new",
"transformed",
"entries",
"list",
"multimap",
"<",
">",
"(",
"from",
"map",
",",
"transformer",
")",
";",
"}"
]
|
[
"execute",
"the",
"test",
"by",
"specify",
"the",
"router",
"heartbeat",
"and",
"nn",
"heartbeat",
"switch"
]
| [
"private",
"void",
"assert",
"router",
"heartbeater",
"(",
"boolean",
"expected",
"router",
"heartbeat",
",",
"boolean",
"expected",
"n",
"n",
"heartbeat",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"router",
"router",
"=",
"new",
"router",
"(",
")",
";",
"configuration",
"base",
"cfg",
"=",
"new",
"router",
"config",
"builder",
"(",
"conf",
")",
"rpc",
"(",
")",
"build",
"(",
")",
";",
"base",
"cfg",
"set",
"boolean",
"(",
"r",
"b",
"f",
"config",
"keys",
"dfs",
"router",
"heartbeat",
"enable",
",",
"expected",
"router",
"heartbeat",
")",
";",
"base",
"cfg",
"set",
"boolean",
"(",
"r",
"b",
"f",
"config",
"keys",
"dfs",
"router",
"namenode",
"heartbeat",
"enable",
",",
"expected",
"n",
"n",
"heartbeat",
")",
";",
"router",
"init",
"(",
"base",
"cfg",
")",
";",
"router",
"heartbeat",
"service",
"router",
"heartbeat",
"service",
"=",
"router",
"get",
"router",
"heartbeat",
"service",
"(",
")",
";",
"if",
"(",
"expected",
"router",
"heartbeat",
")",
"{",
"assert",
"not",
"null",
"(",
"router",
"heartbeat",
"service",
")",
";",
"}",
"else",
"{",
"assert",
"null",
"(",
"router",
"heartbeat",
"service",
")",
";",
"}",
"collection",
"<",
"namenode",
"heartbeat",
"service",
">",
"namenode",
"heartbeat",
"services",
"=",
"router",
"get",
"namenode",
"heartbeat",
"services",
"(",
")",
";",
"if",
"(",
"expected",
"n",
"n",
"heartbeat",
")",
"{",
"assert",
"not",
"null",
"(",
"namenode",
"heartbeat",
"services",
")",
";",
"}",
"else",
"{",
"assert",
"null",
"(",
"namenode",
"heartbeat",
"services",
")",
";",
"}",
"router",
"close",
"(",
")",
";",
"}"
]
|
[
"get",
"map",
"of",
"enum",
"string"
]
| [
"public",
"map",
"<",
"string",
",",
"inner",
"enum",
">",
"get",
"map",
"of",
"enum",
"string",
"(",
")",
"{",
"return",
"map",
"of",
"enum",
"string",
";",
"}"
]
|
[
"wraps",
"a",
"{",
"@",
"link",
"java",
"util",
"concurrent",
"callable",
"}",
"with",
"the",
"{",
"@",
"link",
"queue",
"}",
"lock",
"held"
]
| [
"public",
"static",
"<",
"v",
">",
"java",
"util",
"concurrent",
"callable",
"<",
"v",
">",
"wrap",
"with",
"lock",
"(",
"java",
"util",
"concurrent",
"callable",
"<",
"v",
">",
"callable",
")",
"{",
"final",
"jenkins",
"jenkins",
"=",
"jenkins",
"get",
"instance",
"or",
"null",
"(",
")",
";",
"/",
"/",
"todo",
"confirm",
"safe",
"to",
"assume",
"non",
"-",
"null",
"and",
"use",
"get",
"instance",
"(",
")",
"final",
"queue",
"queue",
"=",
"jenkins",
"=",
"=",
"null",
"?",
"null",
":",
"jenkins",
"get",
"queue",
"(",
")",
";",
"return",
"queue",
"=",
"=",
"null",
"?",
"callable",
":",
"new",
"locked",
"j",
"u",
"c",
"callable",
"<",
">",
"(",
"callable",
")",
";",
"}"
]
|
[
"post",
"fakeinline",
"-",
"additional",
"properties",
":",
"test",
"inline",
"additional",
"properties"
]
| [
"default",
"response",
"entity",
"<",
"void",
">",
"test",
"inline",
"additional",
"properties",
"(",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"request",
"body",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"body",
"map",
"<",
"string",
",",
"string",
">",
"param",
")",
"{",
"return",
"new",
"response",
"entity",
"<",
">",
"(",
"http",
"status",
"not",
"implemented",
")",
";",
"}"
]
|
[
"update",
"all",
"component"
]
| [
"public",
"void",
"update",
"(",
")",
"{",
"logger",
"info",
"(",
"\"",
"update",
"game",
"component",
"\"",
")",
";",
"/",
"/",
"process",
"ai",
"ai",
"component",
"manager",
"update",
"(",
")",
";",
"/",
"/",
"update",
"physics",
"physics",
"component",
"manager",
"update",
"(",
")",
";",
"/",
"/",
"draw",
"to",
"screen",
"render",
"component",
"manager",
"render",
"(",
")",
";",
"}"
]
|
[
"negate",
"this",
"result"
]
| [
"public",
"result",
"negate",
"(",
")",
"{",
"return",
"new",
"result",
"(",
"!",
"this",
"is",
"pass",
"(",
")",
",",
"this",
"is",
"descend",
"(",
")",
")",
";",
"}"
]
|
[
"subclasses",
"can",
"invoke",
"this",
"method",
"to",
"populate",
"the",
"messaging",
"advice",
"bean",
"cache",
"(",
"e",
"g",
"to",
"support",
"\"",
"global",
"\"",
"{",
"@",
"code",
"@",
"message",
"exception",
"handler",
"}",
")"
]
| [
"protected",
"void",
"register",
"exception",
"handler",
"advice",
"(",
"messaging",
"advice",
"bean",
"bean",
",",
"abstract",
"exception",
"handler",
"method",
"resolver",
"resolver",
")",
"{",
"this",
"exception",
"handler",
"advice",
"cache",
"put",
"(",
"bean",
",",
"resolver",
")",
";",
"}"
]
|
[
"add",
"a",
"col",
"element"
]
| [
"table",
"col",
"col",
"(",
"string",
"selector",
")",
";"
]
|
[
"find",
"the",
"fields",
"constant",
"that",
"matches",
"field",
"id",
",",
"throwing",
"an",
"exception",
"if",
"it",
"is",
"not",
"found"
]
| [
"public",
"static",
"fields",
"find",
"by",
"thrift",
"id",
"or",
"throw",
"(",
"int",
"field",
"id",
")",
"{",
"fields",
"fields",
"=",
"find",
"by",
"thrift",
"id",
"(",
"field",
"id",
")",
";",
"if",
"(",
"fields",
"=",
"=",
"null",
")",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"field",
"\"",
"+",
"field",
"id",
"+",
"\"",
"doesn",
"'",
"t",
"exist",
"!",
"\"",
")",
";",
"return",
"fields",
";",
"}"
]
|
[
"deletes",
"all",
"the",
"duplicate",
"node",
"info",
"by",
"discarding",
"the",
"old",
"instances"
]
| [
"public",
"static",
"nodes",
"info",
"delete",
"duplicate",
"nodes",
"info",
"(",
"array",
"list",
"<",
"node",
"info",
">",
"nodes",
")",
"{",
"nodes",
"info",
"nodes",
"info",
"=",
"new",
"nodes",
"info",
"(",
")",
";",
"map",
"<",
"string",
",",
"node",
"info",
">",
"nodes",
"map",
"=",
"new",
"linked",
"hash",
"map",
"<",
">",
"(",
")",
";",
"for",
"(",
"node",
"info",
"node",
":",
"nodes",
")",
"{",
"string",
"node",
"id",
"=",
"node",
"get",
"node",
"id",
"(",
")",
";",
"/",
"/",
"if",
"the",
"node",
"already",
"exists",
",",
"it",
"could",
"be",
"an",
"old",
"instance",
"if",
"(",
"nodes",
"map",
"contains",
"key",
"(",
"node",
"id",
")",
")",
"{",
"/",
"/",
"check",
"if",
"the",
"node",
"is",
"an",
"old",
"instance",
"if",
"(",
"nodes",
"map",
"get",
"(",
"node",
"id",
")",
"get",
"last",
"health",
"update",
"(",
")",
"<",
"node",
"get",
"last",
"health",
"update",
"(",
")",
")",
"{",
"nodes",
"map",
"put",
"(",
"node",
"get",
"node",
"id",
"(",
")",
",",
"node",
")",
";",
"}",
"}",
"else",
"{",
"nodes",
"map",
"put",
"(",
"node",
"get",
"node",
"id",
"(",
")",
",",
"node",
")",
";",
"}",
"}",
"nodes",
"info",
"add",
"all",
"(",
"new",
"array",
"list",
"<",
"node",
"info",
">",
"(",
"nodes",
"map",
"values",
"(",
")",
")",
")",
";",
"return",
"nodes",
"info",
";",
"}"
]
|
[
"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",
"\"",
")",
";",
"}"
]
|
[
"amount",
"of",
"memory",
"allocated",
"to",
"each",
"container",
"(",
"optional",
"but",
"overrides",
"memory",
"in",
"profile",
"if",
"specified",
")",
"currently",
"accepts",
"only",
"an",
"integer",
"value",
"and",
"default",
"unit",
"is",
"in",
"mb"
]
| [
"public",
"resource",
"memory",
"(",
"string",
"memory",
")",
"{",
"this",
"memory",
"=",
"memory",
";",
"return",
"this",
";",
"}"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.