docstring_tokens
list | code_tokens
list |
|---|---|
[
"test",
"normal",
"record",
"storage",
"within",
"a",
"leaf",
"node",
"use",
"null",
"value",
"for",
"variable",
"length",
"fields",
"chained",
"-",
"buffers",
"will",
"not",
"be",
"utilized"
]
| [
"public",
"void",
"test",
"insert",
"var",
"key",
"record",
"with",
"null",
"field",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"insert",
"one",
"var",
"key",
"record",
"(",
"false",
",",
"false",
",",
"-",
"1",
")",
";",
"}"
]
|
[
"creates",
"a",
"ctx",
"map"
]
| [
"public",
"static",
"map",
"<",
"string",
",",
"object",
">",
"create",
"ctx",
"(",
"watch",
"execution",
"context",
"ctx",
",",
"payload",
"payload",
")",
"{",
"map",
"<",
"string",
",",
"object",
">",
"ctx",
"model",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"ctx",
"model",
"put",
"(",
"id",
",",
"ctx",
"id",
"(",
")",
"value",
"(",
")",
")",
";",
"ctx",
"model",
"put",
"(",
"watch",
"id",
",",
"ctx",
"id",
"(",
")",
"watch",
"id",
"(",
")",
")",
";",
"ctx",
"model",
"put",
"(",
"execution",
"time",
",",
"new",
"joda",
"compatible",
"zoned",
"date",
"time",
"(",
"ctx",
"execution",
"time",
"(",
")",
"to",
"instant",
"(",
")",
",",
"zone",
"offset",
"utc",
")",
")",
";",
"ctx",
"model",
"put",
"(",
"trigger",
",",
"ctx",
"trigger",
"event",
"(",
")",
"data",
"(",
")",
")",
";",
"if",
"(",
"payload",
"!",
"=",
"null",
")",
"{",
"ctx",
"model",
"put",
"(",
"payload",
",",
"payload",
"data",
"(",
")",
")",
";",
"}",
"ctx",
"model",
"put",
"(",
"metadata",
",",
"ctx",
"watch",
"(",
")",
"metadata",
"(",
")",
")",
";",
"ctx",
"model",
"put",
"(",
"vars",
",",
"ctx",
"vars",
"(",
")",
")",
";",
"return",
"ctx",
"model",
";",
"}"
]
|
[
"returns",
"the",
"minimum",
"y",
"-",
"value",
"for",
"the",
"specified",
"axis"
]
| [
"public",
"float",
"get",
"y",
"min",
"(",
"axis",
"dependency",
"axis",
")",
"{",
"if",
"(",
"axis",
"=",
"=",
"axis",
"dependency",
"left",
")",
"{",
"if",
"(",
"m",
"left",
"axis",
"min",
"=",
"=",
"float",
"max",
"value",
")",
"{",
"return",
"m",
"right",
"axis",
"min",
";",
"}",
"else",
"return",
"m",
"left",
"axis",
"min",
";",
"}",
"else",
"{",
"if",
"(",
"m",
"right",
"axis",
"min",
"=",
"=",
"float",
"max",
"value",
")",
"{",
"return",
"m",
"left",
"axis",
"min",
";",
"}",
"else",
"return",
"m",
"right",
"axis",
"min",
";",
"}",
"}"
]
|
[
"get",
"a",
"copy",
"of",
"the",
"vertices",
"built",
"so",
"far"
]
| [
"public",
"void",
"get",
"vertices",
"(",
"float",
"[",
"]",
"out",
",",
"int",
"dest",
"offset",
")",
"{",
"if",
"(",
"attributes",
"=",
"=",
"null",
")",
"throw",
"new",
"gdx",
"runtime",
"exception",
"(",
"\"",
"must",
"be",
"called",
"in",
"between",
"#",
"begin",
"and",
"#",
"end",
"\"",
")",
";",
"if",
"(",
"(",
"dest",
"offset",
"<",
"0",
")",
"|",
"|",
"(",
"dest",
"offset",
">",
"out",
"length",
"-",
"vertices",
"size",
")",
")",
"throw",
"new",
"gdx",
"runtime",
"exception",
"(",
"\"",
"array",
"too",
"small",
"or",
"offset",
"out",
"of",
"range",
"\"",
")",
";",
"system",
"arraycopy",
"(",
"vertices",
"items",
",",
"0",
",",
"out",
",",
"dest",
"offset",
",",
"vertices",
"size",
")",
";",
"}"
]
|
[
"exit",
"a",
"parse",
"tree",
"produced",
"by",
"{",
"@",
"link",
"sql",
"base",
"parser",
"#",
"grouping",
"expressions",
"}"
]
| [
"void",
"exit",
"grouping",
"expressions",
"(",
"sql",
"base",
"parser",
"grouping",
"expressions",
"context",
"ctx",
")",
";"
]
|
[
"sets",
"the",
"shard",
"id",
"of",
"the",
"shard",
"to",
"explain"
]
| [
"public",
"cluster",
"allocation",
"explain",
"request",
"set",
"shard",
"(",
"integer",
"shard",
")",
"{",
"this",
"shard",
"=",
"shard",
";",
"return",
"this",
";",
"}"
]
|
[
"refresh",
"the",
"underlying",
"connection",
",",
"not",
"returning",
"before",
"an",
"attempt",
"has",
"been",
"successful",
"called",
"in",
"case",
"of",
"a",
"shared",
"connection",
"as",
"well",
"as",
"without",
"shared",
"connection",
",",
"so",
"either",
"needs",
"to",
"operate",
"on",
"the",
"shared",
"connection",
"or",
"on",
"a",
"temporary",
"connection",
"that",
"just",
"gets",
"established",
"for",
"validation",
"purposes",
"the",
"default",
"implementation",
"retries",
"until",
"it",
"successfully",
"established",
"a",
"connection",
",",
"for",
"as",
"long",
"as",
"this",
"message",
"listener",
"container",
"is",
"running",
"applies",
"the",
"specified",
"recovery",
"interval",
"between",
"retries"
]
| [
"protected",
"void",
"refresh",
"connection",
"until",
"successful",
"(",
")",
"{",
"back",
"off",
"execution",
"execution",
"=",
"this",
"back",
"off",
"start",
"(",
")",
";",
"while",
"(",
"is",
"running",
"(",
")",
")",
"{",
"try",
"{",
"if",
"(",
"shared",
"connection",
"enabled",
"(",
")",
")",
"{",
"refresh",
"shared",
"connection",
"(",
")",
";",
"}",
"else",
"{",
"connection",
"con",
"=",
"create",
"connection",
"(",
")",
";",
"jms",
"utils",
"close",
"connection",
"(",
"con",
")",
";",
"}",
"logger",
"debug",
"(",
"\"",
"successfully",
"refreshed",
"jms",
"connection",
"\"",
")",
";",
"break",
";",
"}",
"catch",
"(",
"exception",
"ex",
")",
"{",
"if",
"(",
"ex",
"instanceof",
"j",
"m",
"s",
"exception",
")",
"{",
"invoke",
"exception",
"listener",
"(",
"(",
"j",
"m",
"s",
"exception",
")",
"ex",
")",
";",
"}",
"string",
"builder",
"msg",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"msg",
"append",
"(",
"\"",
"could",
"not",
"refresh",
"jms",
"connection",
"for",
"destination",
"'",
"\"",
")",
";",
"msg",
"append",
"(",
"get",
"destination",
"description",
"(",
")",
")",
"append",
"(",
"\"",
"'",
"-",
"retrying",
"using",
"\"",
")",
";",
"msg",
"append",
"(",
"execution",
")",
"append",
"(",
"\"",
"cause",
":",
"\"",
")",
";",
"msg",
"append",
"(",
"ex",
"instanceof",
"j",
"m",
"s",
"exception",
"?",
"jms",
"utils",
"build",
"exception",
"message",
"(",
"(",
"j",
"m",
"s",
"exception",
")",
"ex",
")",
":",
"ex",
"get",
"message",
"(",
")",
")",
";",
"if",
"(",
"logger",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"logger",
"error",
"(",
"msg",
",",
"ex",
")",
";",
"}",
"else",
"{",
"logger",
"error",
"(",
"msg",
")",
";",
"}",
"}",
"if",
"(",
"!",
"apply",
"back",
"off",
"time",
"(",
"execution",
")",
")",
"{",
"string",
"builder",
"msg",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"msg",
"append",
"(",
"\"",
"stopping",
"container",
"for",
"destination",
"'",
"\"",
")",
"append",
"(",
"get",
"destination",
"description",
"(",
")",
")",
"append",
"(",
"\"",
"'",
":",
"back",
"-",
"off",
"policy",
"does",
"not",
"allow",
"\"",
")",
"append",
"(",
"\"",
"for",
"further",
"attempts",
"\"",
")",
";",
"logger",
"error",
"(",
"msg",
"to",
"string",
"(",
")",
")",
";",
"stop",
"(",
")",
";",
"}",
"}",
"}"
]
|
[
"add",
"a",
"menu",
"for",
"the",
"given",
"tool",
"template"
]
| [
"private",
"void",
"add",
"config",
"(",
"tool",
"template",
"template",
")",
"{",
"string",
"tool",
"name",
"=",
"template",
"get",
"name",
"(",
")",
";",
"tool",
"action",
"run",
"action",
"=",
"new",
"tool",
"action",
"(",
"tool",
"name",
",",
"\"",
"run",
"tool",
"\"",
")",
"{",
"@",
"override",
"public",
"void",
"action",
"performed",
"(",
"action",
"context",
"context",
")",
"{",
"string",
"name",
"=",
"get",
"name",
"(",
")",
";",
"workspace",
"ws",
"=",
"plugin",
"get",
"active",
"workspace",
"(",
")",
";",
"tool",
"chest",
"tool",
"chest",
"=",
"plugin",
"get",
"active",
"project",
"(",
")",
"get",
"local",
"tool",
"chest",
"(",
")",
";",
"ws",
"run",
"tool",
"(",
"tool",
"chest",
"get",
"tool",
"template",
"(",
"name",
")",
")",
";",
"}",
"}",
";",
"run",
"action",
"set",
"enabled",
"(",
"true",
")",
";",
"run",
"action",
"set",
"menu",
"bar",
"data",
"(",
"new",
"menu",
"data",
"(",
"new",
"string",
"[",
"]",
"{",
"tool",
"constants",
"menu",
"tools",
",",
"menu",
"item",
"run",
"tool",
",",
"tool",
"name",
"}",
",",
"null",
",",
"\"",
"b",
"tools",
"\"",
")",
")",
";",
"run",
"action",
"set",
"help",
"location",
"(",
"new",
"help",
"location",
"(",
"tool",
"constants",
"tool",
"help",
"topic",
",",
"\"",
"run",
"tool",
"\"",
")",
")",
";",
"run",
"tool",
"action",
"map",
"put",
"(",
"tool",
"name",
",",
"run",
"action",
")",
";",
"tool",
"add",
"action",
"(",
"run",
"action",
")",
";",
"tool",
"action",
"delete",
"action",
"=",
"new",
"tool",
"action",
"(",
"tool",
"name",
",",
"\"",
"delete",
"tool",
"\"",
")",
"{",
"@",
"override",
"public",
"void",
"action",
"performed",
"(",
"action",
"context",
"context",
")",
"{",
"string",
"name",
"=",
"get",
"name",
"(",
")",
";",
"if",
"(",
"!",
"plugin",
"confirm",
"delete",
"(",
"name",
"+",
"\"",
"from",
"the",
"project",
"tool",
"chest",
"?",
"\"",
")",
")",
"{",
"return",
";",
"}",
"tool",
"chest",
"tool",
"chest",
"=",
"plugin",
"get",
"active",
"project",
"(",
")",
"get",
"local",
"tool",
"chest",
"(",
")",
";",
"tool",
"chest",
"remove",
"(",
"name",
")",
";",
"}",
"}",
";",
"delete",
"action",
"set",
"enabled",
"(",
"true",
")",
";",
"delete",
"action",
"set",
"menu",
"bar",
"data",
"(",
"new",
"menu",
"data",
"(",
"new",
"string",
"[",
"]",
"{",
"tool",
"constants",
"menu",
"tools",
",",
"menu",
"item",
"delete",
"tool",
",",
"tool",
"name",
"}",
",",
"null",
",",
"\"",
"c",
"tools",
"\"",
")",
")",
";",
"delete",
"action",
"set",
"help",
"location",
"(",
"new",
"help",
"location",
"(",
"tool",
"constants",
"tool",
"help",
"topic",
",",
"\"",
"delete",
"tool",
"\"",
")",
")",
";",
"del",
"tool",
"action",
"map",
"put",
"(",
"tool",
"name",
",",
"delete",
"action",
")",
";",
"tool",
"add",
"action",
"(",
"delete",
"action",
")",
";",
"tool",
"action",
"export",
"tool",
"action",
"=",
"new",
"tool",
"action",
"(",
"tool",
"name",
",",
"\"",
"export",
"tool",
"\"",
")",
"{",
"@",
"override",
"public",
"void",
"action",
"performed",
"(",
"action",
"context",
"context",
")",
"{",
"string",
"name",
"=",
"get",
"name",
"(",
")",
";",
"tool",
"chest",
"tool",
"chest",
"=",
"plugin",
"get",
"active",
"project",
"(",
")",
"get",
"local",
"tool",
"chest",
"(",
")",
";",
"plugin",
"export",
"tool",
"config",
"(",
"tool",
"chest",
"get",
"tool",
"template",
"(",
"name",
")",
",",
"\"",
"tool",
"menu",
"\"",
")",
";",
"}",
"}",
";",
"export",
"tool",
"action",
"set",
"enabled",
"(",
"true",
")",
";",
"export",
"tool",
"action",
"set",
"menu",
"bar",
"data",
"(",
"new",
"menu",
"data",
"(",
"new",
"string",
"[",
"]",
"{",
"tool",
"constants",
"menu",
"tools",
",",
"menu",
"item",
"export",
"tool",
",",
"tool",
"name",
"}",
",",
"null",
",",
"\"",
"d",
"tools",
"\"",
")",
")",
";",
"export",
"tool",
"action",
"set",
"help",
"location",
"(",
"new",
"help",
"location",
"(",
"tool",
"constants",
"tool",
"help",
"topic",
",",
"\"",
"export",
"tool",
"\"",
")",
")",
";",
"export",
"tool",
"action",
"map",
"put",
"(",
"tool",
"name",
",",
"export",
"tool",
"action",
")",
";",
"tool",
"add",
"action",
"(",
"export",
"tool",
"action",
")",
";",
"}"
]
|
[
"acquire",
"a",
"block"
]
| [
"block",
"acquire",
"block",
"(",
")",
"{",
"synchronized",
"(",
"lock",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"block",
"acquired",
"length",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"!",
"block",
"acquired",
"[",
"i",
"]",
"&",
"&",
"blocks",
"[",
"i",
"]",
">",
"=",
"0",
")",
"{",
"block",
"block",
"=",
"new",
"block",
"(",
")",
";",
"block",
"position",
"=",
"i",
";",
"block",
"done",
"=",
"blocks",
"[",
"i",
"]",
";",
"block",
"acquired",
"[",
"i",
"]",
"=",
"true",
";",
"return",
"block",
";",
"}",
"}",
"}",
"return",
"null",
";",
"}"
]
|
[
"general",
"purpose",
"http",
"(",
"s",
")",
"call",
"with",
"json",
"content",
"-",
"type",
"and",
"authorization",
"header",
"ssl",
"settings",
"are",
"read",
"from",
"the",
"settings",
"file",
",",
"if",
"any"
]
| [
"public",
"http",
"response",
"execute",
"(",
"string",
"method",
",",
"url",
"url",
",",
"string",
"user",
",",
"secure",
"string",
"password",
",",
"checked",
"supplier",
"<",
"string",
",",
"exception",
">",
"request",
"body",
"supplier",
",",
"checked",
"function",
"<",
"input",
"stream",
",",
"http",
"response",
"builder",
",",
"exception",
">",
"response",
"handler",
")",
"throws",
"exception",
"{",
"final",
"http",
"u",
"r",
"l",
"connection",
"conn",
";",
"/",
"/",
"if",
"using",
"ssl",
",",
"need",
"a",
"custom",
"service",
"because",
"it",
"'",
"s",
"likely",
"a",
"self",
"-",
"signed",
"certificate",
"if",
"(",
"\"",
"https",
"\"",
"equals",
"ignore",
"case",
"(",
"url",
"get",
"protocol",
"(",
")",
")",
")",
"{",
"final",
"s",
"s",
"l",
"service",
"ssl",
"service",
"=",
"new",
"s",
"s",
"l",
"service",
"(",
"env",
")",
";",
"final",
"https",
"u",
"r",
"l",
"connection",
"https",
"conn",
"=",
"(",
"https",
"u",
"r",
"l",
"connection",
")",
"url",
"open",
"connection",
"(",
")",
";",
"access",
"controller",
"do",
"privileged",
"(",
"(",
"privileged",
"action",
"<",
"void",
">",
")",
"(",
")",
"-",
">",
"{",
"final",
"s",
"s",
"l",
"configuration",
"ssl",
"configuration",
"=",
"ssl",
"service",
"get",
"http",
"transport",
"s",
"s",
"l",
"configuration",
"(",
")",
";",
"/",
"/",
"requires",
"permission",
"java",
"lang",
"runtime",
"permission",
"\"",
"set",
"factory",
"\"",
";",
"https",
"conn",
"set",
"s",
"s",
"l",
"socket",
"factory",
"(",
"ssl",
"service",
"ssl",
"socket",
"factory",
"(",
"ssl",
"configuration",
")",
")",
";",
"final",
"boolean",
"is",
"hostname",
"verification",
"enabled",
"=",
"ssl",
"configuration",
"verification",
"mode",
"(",
")",
"is",
"hostname",
"verification",
"enabled",
"(",
")",
";",
"if",
"(",
"is",
"hostname",
"verification",
"enabled",
"=",
"=",
"false",
")",
"{",
"https",
"conn",
"set",
"hostname",
"verifier",
"(",
"(",
"hostname",
",",
"session",
")",
"-",
">",
"true",
")",
";",
"}",
"return",
"null",
";",
"}",
")",
";",
"conn",
"=",
"https",
"conn",
";",
"}",
"else",
"{",
"conn",
"=",
"(",
"http",
"u",
"r",
"l",
"connection",
")",
"url",
"open",
"connection",
"(",
")",
";",
"}",
"conn",
"set",
"request",
"method",
"(",
"method",
")",
";",
"conn",
"set",
"read",
"timeout",
"(",
"read",
"timeout",
")",
";",
"/",
"/",
"add",
"basic",
"-",
"auth",
"header",
"string",
"token",
"=",
"username",
"password",
"token",
"basic",
"auth",
"header",
"value",
"(",
"user",
",",
"password",
")",
";",
"conn",
"set",
"request",
"property",
"(",
"\"",
"authorization",
"\"",
",",
"token",
")",
";",
"conn",
"set",
"request",
"property",
"(",
"\"",
"content",
"-",
"type",
"\"",
",",
"x",
"content",
"type",
"json",
"media",
"type",
"(",
")",
")",
";",
"string",
"body",
"string",
"=",
"request",
"body",
"supplier",
"get",
"(",
")",
";",
"conn",
"set",
"do",
"output",
"(",
"body",
"string",
"!",
"=",
"null",
")",
";",
"/",
"/",
"set",
"true",
"if",
"we",
"are",
"sending",
"a",
"body",
"socket",
"access",
"do",
"privileged",
"(",
"conn",
":",
":",
"connect",
")",
";",
"if",
"(",
"body",
"string",
"!",
"=",
"null",
")",
"{",
"try",
"(",
"output",
"stream",
"out",
"=",
"conn",
"get",
"output",
"stream",
"(",
")",
")",
"{",
"out",
"write",
"(",
"body",
"string",
"get",
"bytes",
"(",
"standard",
"charsets",
"utf",
"8",
")",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"releasables",
"close",
"while",
"handling",
"exception",
"(",
"conn",
":",
":",
"disconnect",
")",
";",
"throw",
"e",
";",
"}",
"}",
"/",
"/",
"this",
"throws",
"i",
"o",
"exception",
"if",
"there",
"is",
"a",
"network",
"problem",
"final",
"int",
"response",
"code",
"=",
"conn",
"get",
"response",
"code",
"(",
")",
";",
"http",
"response",
"builder",
"response",
"builder",
"=",
"null",
";",
"try",
"(",
"input",
"stream",
"input",
"stream",
"=",
"conn",
"get",
"input",
"stream",
"(",
")",
")",
"{",
"response",
"builder",
"=",
"response",
"handler",
"apply",
"(",
"input",
"stream",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"/",
"/",
"this",
"i",
"o",
"exception",
"is",
"if",
"the",
"http",
"response",
"code",
"is",
"'",
"bad",
"'",
"(",
">",
"=",
"400",
")",
"try",
"(",
"input",
"stream",
"error",
"stream",
"=",
"conn",
"get",
"error",
"stream",
"(",
")",
")",
"{",
"response",
"builder",
"=",
"response",
"handler",
"apply",
"(",
"error",
"stream",
")",
";",
"}",
"}",
"finally",
"{",
"releasables",
"close",
"while",
"handling",
"exception",
"(",
"conn",
":",
":",
"disconnect",
")",
";",
"}",
"response",
"builder",
"with",
"http",
"status",
"(",
"response",
"code",
")",
";",
"return",
"response",
"builder",
"build",
"(",
")",
";",
"}"
]
|
[
"gets",
"a",
"list",
"of",
"all",
"outgoing",
"channels",
"leading",
"to",
"successors"
]
| [
"public",
"list",
"<",
"channel",
">",
"get",
"outgoing",
"channels",
"(",
")",
"{",
"return",
"this",
"out",
"channels",
";",
"}"
]
|
[
"returns",
"the",
"base",
"directory",
"of",
"this",
"reader",
",",
"if",
"any"
]
| [
"public",
"file",
"get",
"base",
"dir",
"(",
")",
"{",
"return",
"include",
"word",
"reader",
"!",
"=",
"null",
"?",
"include",
"word",
"reader",
"get",
"base",
"dir",
"(",
")",
":",
"base",
"dir",
";",
"}"
]
|
[
"creates",
"a",
"helper",
"object",
"(",
"would",
"have",
"been",
"done",
"entirely",
"as",
"an",
"interface",
"with",
"default",
"methods",
"had",
"this",
"been",
"designed",
"for",
"java",
"8",
")"
]
| [
"default",
"parameterized",
"job",
"mix",
"in",
"<",
"job",
"t",
",",
"run",
"t",
">",
"get",
"parameterized",
"job",
"mix",
"in",
"(",
")",
"{",
"return",
"new",
"parameterized",
"job",
"mix",
"in",
"<",
"job",
"t",
",",
"run",
"t",
">",
"(",
")",
"{",
"@",
"suppress",
"warnings",
"(",
"\"",
"unchecked",
"\"",
")",
"/",
"/",
"untypable",
"@",
"override",
"protected",
"job",
"t",
"as",
"job",
"(",
")",
"{",
"return",
"(",
"job",
"t",
")",
"parameterized",
"job",
"this",
";",
"}",
"}",
";",
"}"
]
|
[
"base",
"6",
"4",
"encoded",
"flag"
]
| [
"public",
"api",
"gateway",
"response",
"builder",
"base",
"6",
"4",
"encoded",
"(",
"boolean",
"is",
"base",
"6",
"4",
"encoded",
")",
"{",
"this",
"is",
"base",
"6",
"4",
"encoded",
"=",
"is",
"base",
"6",
"4",
"encoded",
";",
"return",
"this",
";",
"}"
]
|
[
"change",
"the",
"password",
"of",
"a",
"user",
"of",
"a",
"native",
"realm",
"or",
"built",
"-",
"in",
"user",
"asynchronously",
"see",
"<",
"a",
"href",
"=",
"\"",
"https",
":",
"www",
"elastic",
"coguideenelasticsearchreferencecurrentsecurity",
"-",
"api",
"-",
"change",
"-",
"password",
"html",
"\"",
">",
"the",
"docs",
"for",
"more"
]
| [
"public",
"cancellable",
"change",
"password",
"async",
"(",
"request",
"options",
"options",
",",
"change",
"password",
"request",
"request",
",",
"action",
"listener",
"<",
"boolean",
">",
"listener",
")",
"{",
"return",
"change",
"password",
"async",
"(",
"request",
",",
"options",
",",
"listener",
")",
";",
"}"
]
|
[
"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",
"\"",
")",
";",
"}"
]
|
[
"gets",
"the",
"total",
"size",
"in",
"bytes",
"of",
"all",
"currently",
"cached",
"items"
]
| [
"public",
"synchronized",
"int",
"get",
"size",
"in",
"bytes",
"(",
")",
"{",
"return",
"m",
"cached",
"entries",
"get",
"size",
"in",
"bytes",
"(",
")",
";",
"}"
]
|
[
"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",
"\"",
")",
";",
"}"
]
|
[
"creates",
"an",
"{",
"@",
"link",
"authentication",
"}",
"object",
"that",
"represents",
"this",
"user",
"using",
"the",
"given",
"user",
"details"
]
| [
"public",
"@",
"non",
"null",
"authentication",
"impersonate",
"(",
"@",
"non",
"null",
"user",
"details",
"user",
"details",
")",
"{",
"return",
"new",
"username",
"password",
"authentication",
"token",
"(",
"user",
"details",
"get",
"username",
"(",
")",
",",
"\"",
"\"",
",",
"user",
"details",
"get",
"authorities",
"(",
")",
")",
";",
"}"
]
|
[
"all",
"observables",
"will",
"be",
"running",
"in",
"different",
"threads",
"so",
"subscribe",
"(",
")",
"is",
"unblocked",
"count",
"down",
"latch",
"is",
"only",
"used",
"in",
"order",
"to",
"call",
"unsubscribe",
"(",
")",
"in",
"a",
"predictable",
"manner"
]
| [
"public",
"void",
"concat",
"unsubscribe",
"concurrent",
"(",
")",
"{",
"final",
"count",
"down",
"latch",
"call",
"once",
"=",
"new",
"count",
"down",
"latch",
"(",
"1",
")",
";",
"final",
"count",
"down",
"latch",
"ok",
"to",
"continue",
"=",
"new",
"count",
"down",
"latch",
"(",
"1",
")",
";",
"final",
"test",
"observable",
"<",
"string",
">",
"w",
"1",
"=",
"new",
"test",
"observable",
"<",
">",
"(",
"\"",
"one",
"\"",
",",
"\"",
"two",
"\"",
",",
"\"",
"three",
"\"",
")",
";",
"final",
"test",
"observable",
"<",
"string",
">",
"w",
"2",
"=",
"new",
"test",
"observable",
"<",
">",
"(",
"call",
"once",
",",
"ok",
"to",
"continue",
",",
"\"",
"four",
"\"",
",",
"\"",
"five",
"\"",
",",
"\"",
"six",
"\"",
")",
";",
"observer",
"<",
"string",
">",
"observer",
"=",
"test",
"helper",
"mock",
"observer",
"(",
")",
";",
"test",
"observer",
"<",
"string",
">",
"to",
"=",
"new",
"test",
"observer",
"<",
">",
"(",
"observer",
")",
";",
"test",
"observable",
"<",
"observable",
"<",
"string",
">",
">",
"observable",
"of",
"observables",
"=",
"new",
"test",
"observable",
"<",
">",
"(",
"observable",
"unsafe",
"create",
"(",
"w",
"1",
")",
",",
"observable",
"unsafe",
"create",
"(",
"w",
"2",
")",
")",
";",
"observable",
"<",
"string",
">",
"concat",
"f",
"=",
"observable",
"concat",
"(",
"observable",
"unsafe",
"create",
"(",
"observable",
"of",
"observables",
")",
")",
";",
"concat",
"f",
"subscribe",
"(",
"to",
")",
";",
"try",
"{",
"/",
"/",
"block",
"main",
"thread",
"to",
"allow",
"observable",
"\"",
"w",
"1",
"\"",
"to",
"complete",
"and",
"observable",
"\"",
"w",
"2",
"\"",
"to",
"call",
"on",
"next",
"exactly",
"once",
"call",
"once",
"await",
"(",
")",
";",
"/",
"/",
"\"",
"four",
"\"",
"from",
"w",
"2",
"has",
"been",
"processed",
"by",
"on",
"next",
"(",
")",
"to",
"dispose",
"(",
")",
";",
"/",
"/",
"\"",
"five",
"\"",
"and",
"\"",
"six",
"\"",
"will",
"not",
"be",
"processed",
"by",
"on",
"next",
"(",
")",
"/",
"/",
"unblock",
"the",
"observable",
"to",
"continue",
"ok",
"to",
"continue",
"count",
"down",
"(",
")",
";",
"w",
"1",
"t",
"join",
"(",
")",
";",
"w",
"2",
"t",
"join",
"(",
")",
";",
"}",
"catch",
"(",
"throwable",
"e",
")",
"{",
"e",
"print",
"stack",
"trace",
"(",
")",
";",
"fail",
"(",
"e",
"get",
"message",
"(",
")",
")",
";",
"}",
"in",
"order",
"in",
"order",
"=",
"in",
"order",
"(",
"observer",
")",
";",
"in",
"order",
"verify",
"(",
"observer",
",",
"times",
"(",
"1",
")",
")",
"on",
"next",
"(",
"\"",
"one",
"\"",
")",
";",
"in",
"order",
"verify",
"(",
"observer",
",",
"times",
"(",
"1",
")",
")",
"on",
"next",
"(",
"\"",
"two",
"\"",
")",
";",
"in",
"order",
"verify",
"(",
"observer",
",",
"times",
"(",
"1",
")",
")",
"on",
"next",
"(",
"\"",
"three",
"\"",
")",
";",
"in",
"order",
"verify",
"(",
"observer",
",",
"times",
"(",
"1",
")",
")",
"on",
"next",
"(",
"\"",
"four",
"\"",
")",
";",
"in",
"order",
"verify",
"(",
"observer",
",",
"never",
"(",
")",
")",
"on",
"next",
"(",
"\"",
"five",
"\"",
")",
";",
"in",
"order",
"verify",
"(",
"observer",
",",
"never",
"(",
")",
")",
"on",
"next",
"(",
"\"",
"six",
"\"",
")",
";",
"verify",
"(",
"observer",
",",
"never",
"(",
")",
")",
"on",
"complete",
"(",
")",
";",
"verify",
"(",
"observer",
",",
"never",
"(",
")",
")",
"on",
"error",
"(",
"any",
"(",
"throwable",
"class",
")",
")",
";",
"}"
]
|
[
"called",
"to",
"indicate",
"that",
"a",
"nal",
"unit",
"has",
"ended"
]
| [
"public",
"boolean",
"end",
"nal",
"unit",
"(",
"int",
"discard",
"padding",
")",
"{",
"if",
"(",
"!",
"is",
"filling",
")",
"{",
"return",
"false",
";",
"}",
"nal",
"length",
"-",
"=",
"discard",
"padding",
";",
"is",
"filling",
"=",
"false",
";",
"is",
"completed",
"=",
"true",
";",
"return",
"true",
";",
"}"
]
|
[
"adds",
"a",
"usage",
"reference",
"to",
"the",
"build"
]
| [
"public",
"synchronized",
"void",
"add",
"for",
"(",
"@",
"non",
"null",
"run",
"b",
")",
"throws",
"i",
"o",
"exception",
"{",
"add",
"(",
"b",
"get",
"parent",
"(",
")",
"get",
"full",
"name",
"(",
")",
",",
"b",
"get",
"number",
"(",
")",
")",
";",
"}"
]
|
[
"tells",
"a",
"plugin",
"that",
"it",
"is",
"no",
"longer",
"needed",
"the",
"plugin",
"should",
"remove",
"itself",
"from",
"anything",
"that",
"it",
"is",
"registered",
"to",
"and",
"release",
"any",
"resources"
]
| [
"public",
"void",
"dispose",
"(",
")",
"{",
"super",
"dispose",
"(",
")",
";",
"swing",
"mgr",
"dispose",
"(",
")",
";",
"delete",
"action",
"dispose",
"(",
")",
";",
"make",
"selection",
"action",
"dispose",
"(",
")",
";",
"if",
"(",
"sym",
"provider",
"!",
"=",
"null",
")",
"{",
"sym",
"provider",
"dispose",
"(",
")",
";",
"sym",
"provider",
"=",
"null",
";",
"}",
"if",
"(",
"ref",
"provider",
"!",
"=",
"null",
")",
"{",
"ref",
"provider",
"dispose",
"(",
")",
";",
"ref",
"provider",
"=",
"null",
";",
"}",
"if",
"(",
"current",
"program",
"!",
"=",
"null",
")",
"{",
"current",
"program",
"remove",
"listener",
"(",
"this",
")",
";",
"current",
"program",
"=",
"null",
";",
"}",
"goto",
"service",
"=",
"null",
";",
"block",
"model",
"service",
"=",
"null",
";",
"if",
"(",
"inspector",
"!",
"=",
"null",
")",
"{",
"inspector",
"dispose",
"(",
")",
";",
"inspector",
"=",
"null",
";",
"}",
"}"
]
|
[
"arouter",
"-",
"auto",
"-",
"register",
"plugin",
"will",
"generate",
"code",
"inside",
"this",
"method",
"call",
"this",
"method",
"to",
"register",
"all",
"routers",
",",
"interceptors",
"and",
"providers"
]
| [
"private",
"static",
"void",
"load",
"router",
"map",
"(",
")",
"{",
"register",
"by",
"plugin",
"=",
"false",
";",
"/",
"/",
"auto",
"generate",
"register",
"code",
"by",
"gradle",
"plugin",
":",
"arouter",
"-",
"auto",
"-",
"register",
"/",
"/",
"looks",
"like",
"below",
":",
"/",
"/",
"register",
"route",
"root",
"(",
"new",
"a",
"router",
"root",
"modulejava",
"(",
")",
")",
";",
"/",
"/",
"register",
"route",
"root",
"(",
"new",
"a",
"router",
"root",
"modulekotlin",
"(",
")",
")",
";",
"}"
]
|
[
"compare",
"and",
"set",
"in",
"one",
"thread",
"enables",
"another",
"waiting",
"for",
"value",
"to",
"succeed"
]
| [
"public",
"void",
"test",
"compare",
"and",
"set",
"in",
"multiple",
"threads",
"(",
")",
"throws",
"exception",
"{",
"final",
"atomic",
"double",
"at",
"=",
"new",
"atomic",
"double",
"(",
"1",
"0",
")",
";",
"thread",
"t",
"=",
"new",
"started",
"thread",
"(",
"new",
"checked",
"runnable",
"(",
")",
"{",
"public",
"void",
"real",
"run",
"(",
")",
"{",
"while",
"(",
"!",
"at",
"compare",
"and",
"set",
"(",
"2",
"0",
",",
"3",
"0",
")",
")",
"{",
"thread",
"yield",
"(",
")",
";",
"}",
"}",
"}",
")",
";",
"assert",
"true",
"(",
"at",
"compare",
"and",
"set",
"(",
"1",
"0",
",",
"2",
"0",
")",
")",
";",
"await",
"termination",
"(",
"t",
")",
";",
"assert",
"bit",
"equals",
"(",
"3",
"0",
",",
"at",
"get",
"(",
")",
")",
";",
"}"
]
|
[
"return",
"the",
"blockpool",
"id",
"inherent",
"in",
"the",
"currently",
"running",
"namenode"
]
| [
"public",
"static",
"string",
"get",
"current",
"block",
"pool",
"i",
"d",
"(",
"mini",
"d",
"f",
"s",
"cluster",
"cluster",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"cluster",
"!",
"=",
"null",
")",
"{",
"return",
"cluster",
"get",
"name",
"node",
"rpc",
"(",
")",
"version",
"request",
"(",
")",
"get",
"block",
"pool",
"i",
"d",
"(",
")",
";",
"}",
"return",
"namenode",
"storage",
"block",
"pool",
"i",
"d",
";",
"}"
]
|
[
"configure",
"the",
"prefix",
"used",
"to",
"identify",
"user",
"destinations",
"user",
"destinations",
"provide",
"the",
"ability",
"for",
"a",
"user",
"to",
"subscribe",
"to",
"queue",
"names",
"unique",
"to",
"their",
"session",
"as",
"well",
"as",
"for",
"others",
"to",
"send",
"messages",
"to",
"those",
"unique",
",",
"user",
"-",
"specific",
"queues",
"for",
"example",
"when",
"a",
"user",
"attempts",
"to",
"subscribe",
"to",
"\"",
"userqueueposition",
"-",
"updates",
"\"",
",",
"the",
"destination",
"may",
"be",
"translated",
"to",
"\"",
"queueposition",
"-",
"updatesi",
"9oqdfzo",
"\"",
"yielding",
"a",
"unique",
"queue",
"name",
"that",
"does",
"not",
"collide",
"with",
"any",
"other",
"user",
"attempting",
"to",
"do",
"the",
"same",
"subsequently",
"when",
"messages",
"are",
"sent",
"to",
"\"",
"user",
"{",
"username",
"}",
"queueposition",
"-",
"updates",
"\"",
",",
"the",
"destination",
"is",
"translated",
"to",
"\"",
"queueposition",
"-",
"updatesi",
"9oqdfzo",
"\"",
"the",
"default",
"prefix",
"used",
"to",
"identify",
"such",
"destinations",
"is",
"\"",
"user",
"\""
]
| [
"public",
"message",
"broker",
"registry",
"set",
"user",
"destination",
"prefix",
"(",
"string",
"destination",
"prefix",
")",
"{",
"this",
"user",
"destination",
"prefix",
"=",
"destination",
"prefix",
";",
"return",
"this",
";",
"}"
]
|
[
"verifies",
"that",
"the",
"client",
"side",
"decoder",
"works",
"well",
"with",
"buffers",
"sent",
"to",
"a",
"removed",
"input",
"channel",
"the",
"data",
"buffer",
"part",
"should",
"be",
"discarded",
"before",
"reading",
"the",
"next",
"message"
]
| [
"public",
"void",
"test",
"client",
"message",
"decode",
"with",
"removed",
"input",
"channel",
"(",
")",
"throws",
"exception",
"{",
"test",
"netty",
"message",
"client",
"decoding",
"(",
"false",
",",
"false",
",",
"true",
")",
";",
"}"
]
|
[
"remove",
"that",
"can",
"be",
"used",
"in",
"the",
"fluent",
"pattern"
]
| [
"public",
"builder",
"<",
"k",
"type",
",",
"v",
"type",
">",
"f",
"remove",
"(",
"k",
"type",
"key",
")",
"{",
"map",
"remove",
"(",
"key",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"gets",
"whether",
"this",
"type",
"is",
"a",
"primitive",
"type",
"all",
"types",
"are",
"either",
"primitive",
"or",
"reference",
"types"
]
| [
"public",
"boolean",
"is",
"primitive",
"(",
")",
"{",
"switch",
"(",
"basic",
"type",
")",
"{",
"case",
"bt",
"boolean",
":",
"case",
"bt",
"byte",
":",
"case",
"bt",
"char",
":",
"case",
"bt",
"double",
":",
"case",
"bt",
"float",
":",
"case",
"bt",
"int",
":",
"case",
"bt",
"long",
":",
"case",
"bt",
"short",
":",
"case",
"bt",
"void",
":",
"{",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}"
]
|
[
"get",
"the",
"api",
"cilent"
]
| [
"public",
"api",
"client",
"get",
"api",
"client",
"(",
")",
"{",
"return",
"api",
"client",
";",
"}"
]
|
[
"evaluates",
"the",
"window",
"and",
"outputs",
"none",
"or",
"several",
"elements"
]
| [
"void",
"process",
"(",
"key",
"key",
",",
"w",
"window",
",",
"internal",
"window",
"context",
"context",
",",
"in",
"input",
",",
"collector",
"<",
"out",
">",
"out",
")",
"throws",
"exception",
";"
]
|
[
"convert",
"this",
"changelog",
"stream",
"to",
"a",
"{",
"@",
"link",
"k",
"stream",
"}",
"using",
"the",
"given",
"{",
"@",
"link",
"key",
"value",
"mapper",
"}",
"to",
"select",
"the",
"new",
"key",
"for",
"example",
",",
"you",
"can",
"compute",
"the",
"new",
"key",
"as",
"the",
"length",
"of",
"the",
"value",
"string",
"{",
"@",
"code",
"k",
"table",
"<",
"string",
",",
"string",
">",
"table",
"=",
"builder",
"table",
"(",
"\"",
"topic",
"\"",
")",
";",
"k",
"table",
"<",
"integer",
",",
"string",
">",
"keyed",
"stream",
"=",
"table",
"to",
"stream",
"(",
"new",
"key",
"value",
"mapper",
"<",
"string",
",",
"string",
",",
"integer",
">",
"{",
"integer",
"apply",
"(",
"string",
"key",
",",
"string",
"value",
")",
"{",
"return",
"value",
"length",
"(",
")",
";",
"}",
"}",
")",
";",
"}",
"setting",
"a",
"new",
"key",
"might",
"result",
"in",
"an",
"internal",
"data",
"redistribution",
"if",
"a",
"key",
"based",
"operator",
"(",
"like",
"an",
"aggregation",
"or",
"join",
")",
"is",
"applied",
"to",
"the",
"result",
"{",
"@",
"link",
"k",
"stream",
"}",
"this",
"operation",
"is",
"equivalent",
"to",
"calling",
"{",
"@",
"code",
"table",
"}",
"{",
"@",
"link",
"#",
"to",
"stream",
"(",
")",
"to",
"stream",
"}",
"{",
"@",
"code",
"(",
")",
"}",
"{",
"@",
"link",
"k",
"stream",
"#",
"select",
"key",
"(",
"key",
"value",
"mapper",
")",
"select",
"key",
"(",
"key",
"value",
"mapper",
")",
"}",
"note",
"that",
"{",
"@",
"link",
"#",
"to",
"stream",
"(",
")",
"}",
"is",
"a",
"logical",
"operation",
"and",
"only",
"changes",
"the",
"\"",
"interpretation",
"\"",
"of",
"the",
"stream",
",",
"i",
"e",
",",
"each",
"record",
"of",
"this",
"changelog",
"stream",
"is",
"no",
"longer",
"treated",
"as",
"an",
"updated",
"record",
"(",
"cf",
"{",
"@",
"link",
"k",
"stream",
"}",
"vs",
"{",
"@",
"code",
"k",
"table",
"}",
")"
]
| [
"<",
"kr",
">",
"k",
"stream",
"<",
"kr",
",",
"v",
">",
"to",
"stream",
"(",
"final",
"key",
"value",
"mapper",
"<",
"?",
"super",
"k",
",",
"?",
"super",
"v",
",",
"?",
"extends",
"kr",
">",
"mapper",
",",
"final",
"named",
"named",
")",
";"
]
|
[
"reads",
"a",
"constant",
"utf",
"8",
"constant",
"pool",
"entry",
"in",
"{",
"@",
"link",
"#",
"class",
"file",
"buffer",
"}"
]
| [
"final",
"string",
"read",
"utf",
"(",
"final",
"int",
"constant",
"pool",
"entry",
"index",
",",
"final",
"char",
"[",
"]",
"char",
"buffer",
")",
"{",
"string",
"value",
"=",
"constant",
"utf",
"8",
"values",
"[",
"constant",
"pool",
"entry",
"index",
"]",
";",
"if",
"(",
"value",
"!",
"=",
"null",
")",
"{",
"return",
"value",
";",
"}",
"int",
"cp",
"info",
"offset",
"=",
"cp",
"info",
"offsets",
"[",
"constant",
"pool",
"entry",
"index",
"]",
";",
"return",
"constant",
"utf",
"8",
"values",
"[",
"constant",
"pool",
"entry",
"index",
"]",
"=",
"read",
"utf",
"(",
"cp",
"info",
"offset",
"+",
"2",
",",
"read",
"unsigned",
"short",
"(",
"cp",
"info",
"offset",
")",
",",
"char",
"buffer",
")",
";",
"}"
]
|
[
"get",
"direct",
"map"
]
| [
"public",
"map",
"<",
"string",
",",
"boolean",
">",
"get",
"direct",
"map",
"(",
")",
"{",
"return",
"direct",
"map",
";",
"}"
]
|
[
"returns",
"the",
"{",
"@",
"link",
"channel",
"pool",
"handler",
"}",
"that",
"will",
"be",
"notified",
"for",
"the",
"different",
"pool",
"actions"
]
| [
"protected",
"channel",
"pool",
"handler",
"handler",
"(",
")",
"{",
"return",
"handler",
";",
"}"
]
|
[
"get",
"bool",
"item"
]
| [
"public",
"boolean",
"get",
"bool",
"item",
"(",
")",
"{",
"return",
"bool",
"item",
";",
"}"
]
|
[
"returns",
"a",
"list",
"of",
"all",
"files",
"with",
"the",
"given",
"extension",
"that",
"are",
"located",
"in",
"the",
"module",
"of",
"the",
"calling",
"class"
]
| [
"public",
"static",
"list",
"<",
"resource",
"file",
">",
"find",
"files",
"by",
"extension",
"in",
"my",
"module",
"(",
"string",
"extension",
")",
"{",
"resource",
"file",
"my",
"module",
"dir",
"=",
"get",
"my",
"module",
"root",
"directory",
"(",
")",
";",
"if",
"(",
"my",
"module",
"dir",
"=",
"=",
"null",
")",
"{",
"return",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"}",
"return",
"find",
"files",
"by",
"extension",
"(",
"my",
"module",
"dir",
"get",
"name",
"(",
")",
",",
"extension",
")",
";",
"}"
]
|
[
"build",
"the",
"exception",
"to",
"raise",
"on",
"user",
"-",
"aborted",
"action"
]
| [
"protected",
"static",
"exit",
"util",
"exit",
"exception",
"user",
"aborted",
"(",
"string",
"format",
",",
"object",
"args",
")",
"{",
"return",
"exit",
"exception",
"(",
"error",
",",
"format",
",",
"args",
")",
";",
"}"
]
|
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"the",
"given",
"media",
"type",
"includes",
"any",
"of",
"the",
"{",
"@",
"linkplain",
"#",
"set",
"supported",
"media",
"types",
"(",
"list",
")",
"supported",
"media",
"types",
"}"
]
| [
"protected",
"boolean",
"can",
"write",
"(",
"@",
"nullable",
"media",
"type",
"media",
"type",
")",
"{",
"if",
"(",
"media",
"type",
"=",
"=",
"null",
"|",
"|",
"media",
"type",
"all",
"equals",
"type",
"and",
"subtype",
"(",
"media",
"type",
")",
")",
"{",
"return",
"true",
";",
"}",
"for",
"(",
"media",
"type",
"supported",
"media",
"type",
":",
"get",
"supported",
"media",
"types",
"(",
")",
")",
"{",
"if",
"(",
"supported",
"media",
"type",
"is",
"compatible",
"with",
"(",
"media",
"type",
")",
")",
"{",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}"
]
|
[
"files",
"exported",
"from",
"jars",
"are",
"exported",
"into",
"a",
"certain",
"folder",
"so",
"that",
"we",
"can",
"rebuild",
"them",
"when",
"the",
"related",
"jar",
"file",
"changes"
]
| [
"private",
"static",
"string",
"get",
"jar",
"file",
"prefix",
"(",
"@",
"non",
"null",
"file",
"input",
"file",
")",
"{",
"/",
"/",
"get",
"the",
"filename",
"string",
"name",
"=",
"input",
"file",
"get",
"name",
"(",
")",
";",
"/",
"/",
"remove",
"the",
"extension",
"int",
"pos",
"=",
"name",
"last",
"index",
"of",
"(",
"'",
"'",
")",
";",
"if",
"(",
"pos",
"!",
"=",
"-",
"1",
")",
"{",
"name",
"=",
"name",
"substring",
"(",
"0",
",",
"pos",
")",
";",
"}",
"/",
"/",
"add",
"a",
"hash",
"of",
"the",
"original",
"file",
"path",
"string",
"input",
"=",
"input",
"file",
"get",
"absolute",
"path",
"(",
")",
";",
"hash",
"function",
"hash",
"function",
"=",
"hashing",
"sha",
"1",
"(",
")",
";",
"hash",
"code",
"hash",
"code",
"=",
"hash",
"function",
"hash",
"string",
"(",
"input",
",",
"charsets",
"utf",
"16le",
")",
";",
"return",
"name",
"+",
"\"",
"-",
"\"",
"+",
"hash",
"code",
"to",
"string",
"(",
")",
";",
"}"
]
|
[
"allows",
"plugging",
"in",
"election",
"strategies",
"(",
"see",
"{",
"@",
"link",
"election",
"strategy",
"}",
")",
"that",
"define",
"a",
"customized",
"notion",
"of",
"an",
"election",
"quorum"
]
| [
"default",
"map",
"<",
"string",
",",
"election",
"strategy",
">",
"get",
"election",
"strategies",
"(",
")",
"{",
"return",
"collections",
"empty",
"map",
"(",
")",
";",
"}"
]
|
[
"returns",
"true",
"if",
"this",
"{",
"@",
"code",
"test",
"subscriber",
"}",
"has",
"been",
"cancelled"
]
| [
"public",
"final",
"boolean",
"is",
"cancelled",
"(",
")",
"{",
"return",
"cancelled",
";",
"}"
]
|
[
"returns",
"the",
"name",
"of",
"the",
"instruction"
]
| [
"public",
"string",
"get",
"name",
"(",
")",
"{",
"return",
"instruction",
"constants",
"names",
"[",
"opcode",
"&",
"0xff",
"]",
";",
"}"
]
|
[
"writes",
"out",
"all",
"properties",
"and",
"their",
"attributes",
"(",
"final",
"and",
"resource",
")",
"to",
"the",
"given",
"{",
"@",
"link",
"writer",
"}",
",",
"the",
"format",
"of",
"the",
"output",
"would",
"be",
",",
"{",
"\"",
"properties",
"\"",
":",
"[",
"{",
"key",
":",
"\"",
"key",
"1",
"\"",
",",
"value",
":",
"\"",
"value",
"1",
"\"",
",",
"is",
"final",
":",
"\"",
"key",
"1",
"is",
"final",
"\"",
",",
"resource",
":",
"\"",
"key",
"1",
"resource",
"\"",
"}",
",",
"{",
"key",
":",
"\"",
"key",
"2",
"\"",
",",
"value",
":",
"\"",
"value",
"2",
"\"",
",",
"is",
"final",
":",
"\"",
"ke",
"2",
"is",
"final",
"\"",
",",
"resource",
":",
"\"",
"key",
"2",
"resource",
"\"",
"}",
"]",
"}",
"it",
"does",
"not",
"output",
"the",
"properties",
"of",
"the",
"configuration",
"object",
"which",
"is",
"loaded",
"from",
"an",
"input",
"stream"
]
| [
"public",
"static",
"void",
"dump",
"configuration",
"(",
"configuration",
"config",
",",
"writer",
"out",
")",
"throws",
"i",
"o",
"exception",
"{",
"json",
"factory",
"dump",
"factory",
"=",
"new",
"json",
"factory",
"(",
")",
";",
"json",
"generator",
"dump",
"generator",
"=",
"dump",
"factory",
"create",
"generator",
"(",
"out",
")",
";",
"dump",
"generator",
"write",
"start",
"object",
"(",
")",
";",
"dump",
"generator",
"write",
"field",
"name",
"(",
"\"",
"properties",
"\"",
")",
";",
"dump",
"generator",
"write",
"start",
"array",
"(",
")",
";",
"dump",
"generator",
"flush",
"(",
")",
";",
"config",
"redactor",
"redactor",
"=",
"new",
"config",
"redactor",
"(",
"config",
")",
";",
"synchronized",
"(",
"config",
")",
"{",
"for",
"(",
"map",
"entry",
"<",
"object",
",",
"object",
">",
"item",
":",
"config",
"get",
"props",
"(",
")",
"entry",
"set",
"(",
")",
")",
"{",
"append",
"j",
"s",
"o",
"n",
"property",
"(",
"dump",
"generator",
",",
"config",
",",
"item",
"get",
"key",
"(",
")",
"to",
"string",
"(",
")",
",",
"redactor",
")",
";",
"}",
"}",
"dump",
"generator",
"write",
"end",
"array",
"(",
")",
";",
"dump",
"generator",
"write",
"end",
"object",
"(",
")",
";",
"dump",
"generator",
"flush",
"(",
")",
";",
"}"
]
|
[
"get",
"namespace",
"integer"
]
| [
"public",
"integer",
"get",
"namespace",
"integer",
"(",
")",
"{",
"return",
"namespace",
"integer",
";",
"}"
]
|
[
"returns",
"the",
"index",
"of",
"the",
"first",
"matching",
"bmp",
"character",
"in",
"a",
"character",
"sequence",
",",
"starting",
"from",
"a",
"given",
"position",
",",
"or",
"{",
"@",
"code",
"-",
"1",
"}",
"if",
"no",
"character",
"matches",
"after",
"that",
"position",
"the",
"default",
"implementation",
"iterates",
"over",
"the",
"sequence",
"in",
"forward",
"order",
",",
"beginning",
"at",
"{",
"@",
"code",
"start",
"}",
",",
"calling",
"{",
"@",
"link",
"#",
"matches",
"}",
"for",
"each",
"character"
]
| [
"public",
"int",
"index",
"in",
"(",
"char",
"sequence",
"sequence",
",",
"int",
"start",
")",
"{",
"int",
"length",
"=",
"sequence",
"length",
"(",
")",
";",
"check",
"position",
"index",
"(",
"start",
",",
"length",
")",
";",
"for",
"(",
"int",
"i",
"=",
"start",
";",
"i",
"<",
"length",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"matches",
"(",
"sequence",
"char",
"at",
"(",
"i",
")",
")",
")",
"{",
"return",
"i",
";",
"}",
"}",
"return",
"-",
"1",
";",
"}"
]
|
[
"{",
"@",
"inherit",
"doc",
"}",
"the",
"default",
"implementation",
"returns",
"the",
"result",
"of",
"calling",
"{",
"@",
"link",
"#",
"visit",
"children",
"}",
"on",
"{",
"@",
"code",
"ctx",
"}"
]
| [
"@",
"override",
"public",
"t",
"visit",
"binary",
"(",
"painless",
"parser",
"binary",
"context",
"ctx",
")",
"{",
"return",
"visit",
"children",
"(",
"ctx",
")",
";",
"}"
]
|
[
"if",
"the",
"test",
"method",
"of",
"the",
"supplied",
"{",
"@",
"linkplain",
"test",
"context",
"test",
"context",
"}",
"is",
"configured",
"to",
"run",
"within",
"a",
"transaction",
",",
"this",
"method",
"will",
"run",
"{",
"@",
"link",
"before",
"transaction",
"@",
"before",
"transaction",
"}",
"methods",
"and",
"start",
"a",
"new",
"transaction",
"note",
"that",
"if",
"a",
"{",
"@",
"code",
"@",
"before",
"transaction",
"}",
"method",
"fails",
",",
"any",
"remaining",
"{",
"@",
"code",
"@",
"before",
"transaction",
"}",
"methods",
"will",
"not",
"be",
"invoked",
",",
"and",
"a",
"transaction",
"will",
"not",
"be",
"started"
]
| [
"public",
"void",
"before",
"test",
"method",
"(",
"final",
"test",
"context",
"test",
"context",
")",
"throws",
"exception",
"{",
"method",
"test",
"method",
"=",
"test",
"context",
"get",
"test",
"method",
"(",
")",
";",
"class",
"<",
"?",
">",
"test",
"class",
"=",
"test",
"context",
"get",
"test",
"class",
"(",
")",
";",
"assert",
"not",
"null",
"(",
"test",
"method",
",",
"\"",
"test",
"method",
"of",
"supplied",
"test",
"context",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"transaction",
"context",
"tx",
"context",
"=",
"transaction",
"context",
"holder",
"remove",
"current",
"transaction",
"context",
"(",
")",
";",
"assert",
"state",
"(",
"tx",
"context",
"=",
"=",
"null",
",",
"\"",
"cannot",
"start",
"new",
"transaction",
"without",
"ending",
"existing",
"transaction",
"\"",
")",
";",
"platform",
"transaction",
"manager",
"tm",
"=",
"null",
";",
"transaction",
"attribute",
"transaction",
"attribute",
"=",
"this",
"attribute",
"source",
"get",
"transaction",
"attribute",
"(",
"test",
"method",
",",
"test",
"class",
")",
";",
"if",
"(",
"transaction",
"attribute",
"!",
"=",
"null",
")",
"{",
"transaction",
"attribute",
"=",
"test",
"context",
"transaction",
"utils",
"create",
"delegating",
"transaction",
"attribute",
"(",
"test",
"context",
",",
"transaction",
"attribute",
")",
";",
"if",
"(",
"logger",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"logger",
"debug",
"(",
"\"",
"explicit",
"transaction",
"definition",
"[",
"\"",
"+",
"transaction",
"attribute",
"+",
"\"",
"]",
"found",
"for",
"test",
"context",
"\"",
"+",
"test",
"context",
")",
";",
"}",
"if",
"(",
"transaction",
"attribute",
"get",
"propagation",
"behavior",
"(",
")",
"=",
"=",
"transaction",
"definition",
"propagation",
"not",
"supported",
"|",
"|",
"transaction",
"attribute",
"get",
"propagation",
"behavior",
"(",
")",
"=",
"=",
"transaction",
"definition",
"propagation",
"never",
")",
"{",
"return",
";",
"}",
"tm",
"=",
"get",
"transaction",
"manager",
"(",
"test",
"context",
",",
"transaction",
"attribute",
"get",
"qualifier",
"(",
")",
")",
";",
"assert",
"state",
"(",
"tm",
"!",
"=",
"null",
",",
"(",
")",
"-",
">",
"\"",
"failed",
"to",
"retrieve",
"platform",
"transaction",
"manager",
"for",
"@",
"transactional",
"test",
":",
"\"",
"+",
"test",
"context",
")",
";",
"}",
"if",
"(",
"tm",
"!",
"=",
"null",
")",
"{",
"tx",
"context",
"=",
"new",
"transaction",
"context",
"(",
"test",
"context",
",",
"tm",
",",
"transaction",
"attribute",
",",
"is",
"rollback",
"(",
"test",
"context",
")",
")",
";",
"run",
"before",
"transaction",
"methods",
"(",
"test",
"context",
")",
";",
"tx",
"context",
"start",
"transaction",
"(",
")",
";",
"transaction",
"context",
"holder",
"set",
"current",
"transaction",
"context",
"(",
"tx",
"context",
")",
";",
"}",
"}"
]
|
[
"logs",
"out",
"current",
"logged",
"in",
"user",
"session"
]
| [
"public",
"void",
"logout",
"user",
"(",
"api",
"client",
"auth",
"info",
"auth",
"info",
",",
"handler",
"<",
"async",
"result",
"<",
"void",
">",
">",
"result",
"handler",
")",
"{",
"object",
"local",
"var",
"body",
"=",
"null",
";",
"/",
"/",
"create",
"path",
"and",
"map",
"variables",
"string",
"local",
"var",
"path",
"=",
"\"",
"/",
"user",
"/",
"logout",
"\"",
";",
"/",
"/",
"query",
"params",
"list",
"<",
"pair",
">",
"local",
"var",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"/",
"/",
"header",
"params",
"multi",
"map",
"local",
"var",
"header",
"params",
"=",
"multi",
"map",
"case",
"insensitive",
"multi",
"map",
"(",
")",
";",
"/",
"/",
"cookie",
"params",
"multi",
"map",
"local",
"var",
"cookie",
"params",
"=",
"multi",
"map",
"case",
"insensitive",
"multi",
"map",
"(",
")",
";",
"/",
"/",
"form",
"params",
"/",
"/",
"todo",
":",
"sending",
"files",
"within",
"multipart",
"/",
"form",
"-",
"data",
"is",
"not",
"supported",
"yet",
"(",
"because",
"of",
"vertx",
"web",
"-",
"client",
")",
"map",
"<",
"string",
",",
"object",
">",
"local",
"var",
"form",
"params",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"string",
"[",
"]",
"local",
"var",
"accepts",
"=",
"{",
"}",
";",
"string",
"[",
"]",
"local",
"var",
"content",
"types",
"=",
"{",
"}",
";",
"string",
"[",
"]",
"local",
"var",
"auth",
"names",
"=",
"new",
"string",
"[",
"]",
"{",
"}",
";",
"api",
"client",
"invoke",
"a",
"p",
"i",
"(",
"local",
"var",
"path",
",",
"\"",
"get",
"\"",
",",
"local",
"var",
"query",
"params",
",",
"local",
"var",
"body",
",",
"local",
"var",
"header",
"params",
",",
"local",
"var",
"cookie",
"params",
",",
"local",
"var",
"form",
"params",
",",
"local",
"var",
"accepts",
",",
"local",
"var",
"content",
"types",
",",
"local",
"var",
"auth",
"names",
",",
"auth",
"info",
",",
"null",
",",
"result",
"handler",
")",
";",
"}"
]
|
[
"test",
"for",
"the",
"case",
"where",
"the",
"shared",
"edits",
"dir",
"doesn",
"'",
"t",
"have",
"all",
"of",
"the",
"recent",
"edit",
"logs"
]
| [
"public",
"void",
"test",
"shared",
"edits",
"missing",
"logs",
"(",
")",
"throws",
"exception",
"{",
"remove",
"standby",
"name",
"dirs",
"(",
")",
";",
"checkpoint",
"signature",
"sig",
"=",
"nn",
"0",
"get",
"rpc",
"server",
"(",
")",
"roll",
"edit",
"log",
"(",
")",
";",
"assert",
"equals",
"(",
"3",
",",
"sig",
"get",
"cur",
"segment",
"tx",
"id",
"(",
")",
")",
";",
"/",
"/",
"should",
"have",
"created",
"edits",
"1",
"-",
"2",
"in",
"shared",
"edits",
"dir",
"uri",
"edits",
"uri",
"=",
"cluster",
"get",
"shared",
"edits",
"dir",
"(",
"0",
",",
"max",
"n",
"n",
"count",
"-",
"1",
")",
";",
"file",
"edits",
"dir",
"=",
"new",
"file",
"(",
"edits",
"uri",
")",
";",
"file",
"current",
"dir",
"=",
"new",
"file",
"(",
"edits",
"dir",
",",
"\"",
"current",
"\"",
")",
";",
"file",
"edits",
"segment",
"=",
"new",
"file",
"(",
"current",
"dir",
",",
"n",
"n",
"storage",
"get",
"finalized",
"edits",
"file",
"name",
"(",
"1",
",",
"2",
")",
")",
";",
"generic",
"test",
"utils",
"assert",
"exists",
"(",
"edits",
"segment",
")",
";",
"generic",
"test",
"utils",
"assert",
"exists",
"(",
"current",
"dir",
")",
";",
"/",
"/",
"delete",
"the",
"segment",
"assert",
"true",
"(",
"edits",
"segment",
"delete",
"(",
")",
")",
";",
"/",
"/",
"trying",
"to",
"bootstrap",
"standby",
"should",
"now",
"fail",
"since",
"the",
"edit",
"/",
"/",
"logs",
"aren",
"'",
"t",
"available",
"in",
"the",
"shared",
"dir",
"log",
"capturer",
"logs",
"=",
"generic",
"test",
"utils",
"log",
"capturer",
"capture",
"logs",
"(",
"logger",
"factory",
"get",
"logger",
"(",
"bootstrap",
"standby",
"class",
")",
")",
";",
"try",
"{",
"assert",
"equals",
"(",
"bootstrap",
"standby",
"err",
"code",
"logs",
"unavailable",
",",
"force",
"bootstrap",
"(",
"1",
")",
")",
";",
"}",
"finally",
"{",
"logs",
"stop",
"capturing",
"(",
")",
";",
"}",
"assert",
"true",
"(",
"logs",
"get",
"output",
"(",
")",
"contains",
"(",
"\"",
"unable",
"to",
"read",
"transaction",
"ids",
"1",
"-",
"3",
"from",
"the",
"configured",
"shared",
"\"",
")",
")",
";",
"}"
]
|
[
"register",
"a",
"listener",
"that",
"will",
"be",
"called",
"when",
"this",
"model",
"is",
"unbound",
"from",
"a",
"view",
"the",
"listener",
"will",
"contribute",
"to",
"this",
"model",
"'",
"s",
"hash",
"code",
"state",
"per",
"the",
"{",
"@",
"link",
"com",
"airbnb",
"epoxy",
"epoxy",
"attribute",
"option",
"#",
"do",
"not",
"hash",
"}",
"rules",
"you",
"may",
"clear",
"the",
"listener",
"by",
"setting",
"a",
"null",
"value",
",",
"or",
"by",
"calling",
"{",
"@",
"link",
"#",
"reset",
"(",
")",
"}"
]
| [
"public",
"test",
"field",
"prop",
"text",
"prop",
"view",
"model",
"on",
"unbind",
"(",
"on",
"model",
"unbound",
"listener",
"<",
"test",
"field",
"prop",
"text",
"prop",
"view",
"model",
",",
"test",
"field",
"prop",
"text",
"prop",
"view",
">",
"listener",
")",
"{",
"on",
"mutation",
"(",
")",
";",
"this",
"on",
"model",
"unbound",
"listener",
"epoxy",
"generated",
"model",
"=",
"listener",
";",
"return",
"this",
";",
"}"
]
|
[
"remove",
"the",
"module",
"record"
]
| [
"boolean",
"remove",
"module",
"record",
"(",
"long",
"child",
"i",
"d",
")",
"throws",
"i",
"o",
"exception",
";"
]
|
[
"pack",
"order",
"list",
"of",
"certs",
"to",
"create",
"a",
"certificate",
"chain",
"array"
]
| [
"private",
"static",
"certificate",
"[",
"]",
"get",
"certificate",
"chain",
"(",
"certificate",
"certs",
")",
"{",
"list",
"<",
"certificate",
">",
"list",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"for",
"(",
"certificate",
"cert",
":",
"certs",
")",
"{",
"if",
"(",
"cert",
"!",
"=",
"null",
")",
"{",
"list",
"add",
"(",
"cert",
")",
";",
"}",
"}",
"certificate",
"[",
"]",
"chain",
"=",
"new",
"certificate",
"[",
"list",
"size",
"(",
")",
"]",
";",
"return",
"list",
"to",
"array",
"(",
"chain",
")",
";",
"}"
]
|
[
"match",
"a",
"string",
"against",
"the",
"given",
"patterns",
",",
"supporting",
"the",
"following",
"simple",
"pattern",
"styles",
":",
"\"",
"xxx",
"\"",
",",
"\"",
"xxx",
"\"",
",",
"\"",
"xxx",
"\"",
"and",
"\"",
"xxxyyy",
"\"",
"matches",
"(",
"with",
"an",
"arbitrary",
"number",
"of",
"pattern",
"parts",
")",
",",
"as",
"well",
"as",
"direct",
"equality"
]
| [
"public",
"static",
"boolean",
"simple",
"match",
"(",
"string",
"[",
"]",
"patterns",
",",
"string",
"str",
")",
"{",
"if",
"(",
"patterns",
"!",
"=",
"null",
")",
"{",
"for",
"(",
"string",
"pattern",
":",
"patterns",
")",
"{",
"if",
"(",
"simple",
"match",
"(",
"pattern",
",",
"str",
")",
")",
"{",
"return",
"true",
";",
"}",
"}",
"}",
"return",
"false",
";",
"}"
]
|
[
"factory",
"for",
"\"",
"16",
"\"",
"version",
"of",
"{",
"@",
"link",
"procedure",
"start",
"mips",
"symbol",
"internals",
"}"
]
| [
"public",
"static",
"procedure",
"start",
"mips",
"symbol",
"internals",
"parse",
"(",
"abstract",
"pdb",
"pdb",
",",
"pdb",
"byte",
"reader",
"reader",
")",
"throws",
"pdb",
"exception",
"{",
"procedure",
"start",
"mips",
"symbol",
"internals",
"result",
"=",
"new",
"procedure",
"start",
"mips",
"symbol",
"internals",
"(",
"pdb",
")",
";",
"parse",
"initial",
"fields",
"(",
"pdb",
",",
"reader",
",",
"result",
")",
";",
"/",
"/",
"note",
"parsing",
"order",
"and",
"sizes",
"result",
"type",
"record",
"number",
"=",
"record",
"number",
"parse",
"(",
"pdb",
",",
"reader",
",",
"record",
"category",
"type",
",",
"32",
")",
";",
"result",
"symbol",
"offset",
"=",
"reader",
"parse",
"unsigned",
"int",
"val",
"(",
")",
";",
"result",
"symbol",
"segment",
"=",
"pdb",
"parse",
"segment",
"(",
"reader",
")",
";",
"parse",
"more",
"fields",
"(",
"pdb",
",",
"reader",
",",
"result",
")",
";",
"result",
"name",
"=",
"reader",
"parse",
"string",
"(",
"pdb",
",",
"string",
"parse",
"type",
"string",
"utf",
"8",
"nt",
")",
";",
"return",
"result",
";",
"}"
]
|
[
"takes",
"a",
"request",
"that",
"was",
"sent",
"by",
"a",
"{",
"@",
"link",
"transport",
"replication",
"action",
"}",
"and",
"captured",
"and",
"returns",
"the",
"underlying",
"request",
"if",
"it",
"'",
"s",
"wrapped",
"or",
"the",
"original",
"(",
"cast",
"to",
"the",
"expected",
"type",
")",
"this",
"will",
"throw",
"a",
"{",
"@",
"link",
"class",
"cast",
"exception",
"}",
"if",
"the",
"request",
"is",
"of",
"the",
"wrong",
"type"
]
| [
"public",
"static",
"<",
"r",
"extends",
"replication",
"request",
">",
"r",
"resolve",
"request",
"(",
"transport",
"request",
"request",
"or",
"wrapped",
"request",
")",
"{",
"if",
"(",
"request",
"or",
"wrapped",
"request",
"instanceof",
"transport",
"replication",
"action",
"concrete",
"shard",
"request",
")",
"{",
"request",
"or",
"wrapped",
"request",
"=",
"(",
"(",
"transport",
"replication",
"action",
"concrete",
"shard",
"request",
"<",
"?",
">",
")",
"request",
"or",
"wrapped",
"request",
")",
"get",
"request",
"(",
")",
";",
"}",
"/",
"/",
"noinspection",
"unchecked",
"return",
"(",
"r",
")",
"request",
"or",
"wrapped",
"request",
";",
"}"
]
|
[
"helper",
"method",
"for",
"determining",
"whether",
"or",
"not",
"to",
"ignore",
"inbound",
"frames",
"a",
"stream",
"is",
"considered",
"to",
"be",
"created",
"after",
"a",
"{",
"@",
"code",
"goaway",
"}",
"is",
"sent",
"if",
"the",
"following",
"conditions",
"hold",
":",
"<",
"p",
">",
"a",
"{",
"@",
"code",
"goaway",
"}",
"must",
"have",
"been",
"sent",
"by",
"the",
"local",
"endpoint",
"the",
"{",
"@",
"code",
"stream",
"id",
"}",
"must",
"identify",
"a",
"legitimate",
"stream",
"id",
"for",
"the",
"remote",
"endpoint",
"to",
"be",
"creating",
"{",
"@",
"code",
"stream",
"id",
"}",
"is",
"greater",
"than",
"the",
"last",
"known",
"stream",
"id",
"which",
"was",
"sent",
"by",
"the",
"local",
"endpoint",
"in",
"the",
"last",
"{",
"@",
"code",
"goaway",
"}",
"frame",
"<",
"p",
">"
]
| [
"private",
"boolean",
"stream",
"created",
"after",
"go",
"away",
"sent",
"(",
"int",
"stream",
"id",
")",
"{",
"endpoint",
"<",
"?",
">",
"remote",
"=",
"connection",
"remote",
"(",
")",
";",
"return",
"connection",
"go",
"away",
"sent",
"(",
")",
"&",
"&",
"remote",
"is",
"valid",
"stream",
"id",
"(",
"stream",
"id",
")",
"&",
"&",
"stream",
"id",
">",
"remote",
"last",
"stream",
"known",
"by",
"peer",
"(",
")",
";",
"}"
]
|
[
"create",
"an",
"{",
"@",
"link",
"aspect",
"metadata",
"}",
"instance",
"for",
"the",
"supplied",
"aspect",
"type"
]
| [
"private",
"aspect",
"metadata",
"create",
"aspect",
"metadata",
"(",
"class",
"<",
"?",
">",
"aspect",
"class",
",",
"string",
"aspect",
"name",
")",
"{",
"aspect",
"metadata",
"am",
"=",
"new",
"aspect",
"metadata",
"(",
"aspect",
"class",
",",
"aspect",
"name",
")",
";",
"if",
"(",
"!",
"am",
"get",
"aj",
"type",
"(",
")",
"is",
"aspect",
"(",
")",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"class",
"[",
"\"",
"+",
"aspect",
"class",
"get",
"name",
"(",
")",
"+",
"\"",
"]",
"is",
"not",
"a",
"valid",
"aspect",
"type",
"\"",
")",
";",
"}",
"return",
"am",
";",
"}"
]
|
[
"called",
"after",
"the",
"index",
"has",
"been",
"created"
]
| [
"default",
"void",
"after",
"index",
"created",
"(",
"index",
"service",
"index",
"service",
")",
"{",
"}"
]
|
[
"add",
"an",
"entry",
"to",
"a",
"stanza"
]
| [
"public",
"void",
"add",
"child",
"(",
"string",
"name",
",",
"stanza",
"child",
")",
"{",
"linked",
"list",
"<",
"stanza",
">",
"l",
";",
"if",
"(",
"subtrees",
"contains",
"key",
"(",
"name",
")",
")",
"{",
"l",
"=",
"subtrees",
"get",
"(",
"name",
")",
";",
"}",
"else",
"{",
"l",
"=",
"new",
"linked",
"list",
"<",
"stanza",
">",
"(",
")",
";",
"subtrees",
"put",
"(",
"name",
",",
"l",
")",
";",
"}",
"l",
"add",
"(",
"child",
")",
";",
"}"
]
|
[
"get",
"information",
"about",
"the",
"application",
"identified",
"by",
"the",
"input",
"{",
"@",
"code",
"application",
"id",
"}"
]
| [
"get",
"application",
"home",
"sub",
"cluster",
"response",
"get",
"application",
"home",
"sub",
"cluster",
"(",
"get",
"application",
"home",
"sub",
"cluster",
"request",
"request",
")",
"throws",
"yarn",
"exception",
";"
]
|
[
"returns",
"a",
"suffix",
"string",
"based",
"on",
"the",
"node",
"role",
"if",
"no",
"explicit",
"role",
"is",
"defined",
",",
"the",
"suffix",
"will",
"be",
"empty"
]
| [
"private",
"static",
"string",
"get",
"role",
"suffix",
"(",
"settings",
"settings",
")",
"{",
"string",
"suffix",
"=",
"\"",
"\"",
";",
"/",
"/",
"only",
"add",
"the",
"suffixes",
"if",
"roles",
"are",
"explicitly",
"defined",
"if",
"(",
"settings",
"has",
"value",
"(",
"\"",
"nodes",
"roles",
"\"",
")",
")",
"{",
"if",
"(",
"discovery",
"node",
"has",
"role",
"(",
"settings",
",",
"discovery",
"node",
"role",
"master",
"role",
")",
")",
"{",
"suffix",
"=",
"suffix",
"+",
"discovery",
"node",
"role",
"master",
"role",
"role",
"name",
"abbreviation",
"(",
")",
";",
"}",
"if",
"(",
"discovery",
"node",
"is",
"data",
"node",
"(",
"settings",
")",
")",
"{",
"suffix",
"=",
"suffix",
"+",
"discovery",
"node",
"role",
"data",
"role",
"role",
"name",
"abbreviation",
"(",
")",
";",
"}",
"if",
"(",
"discovery",
"node",
"has",
"role",
"(",
"settings",
",",
"discovery",
"node",
"role",
"master",
"role",
")",
"=",
"=",
"false",
"&",
"&",
"discovery",
"node",
"is",
"data",
"node",
"(",
"settings",
")",
"=",
"=",
"false",
")",
"{",
"suffix",
"=",
"suffix",
"+",
"\"",
"c",
"\"",
";",
"}",
"}",
"return",
"suffix",
";",
"}"
]
|
[
"checks",
",",
"whether",
"the",
"given",
"class",
"has",
"a",
"public",
"nullary",
"constructor"
]
| [
"public",
"static",
"boolean",
"has",
"public",
"nullary",
"constructor",
"(",
"class",
"<",
"?",
">",
"clazz",
")",
"{",
"constructor",
"<",
"?",
">",
"[",
"]",
"constructors",
"=",
"clazz",
"get",
"constructors",
"(",
")",
";",
"for",
"(",
"constructor",
"<",
"?",
">",
"constructor",
":",
"constructors",
")",
"{",
"if",
"(",
"constructor",
"get",
"parameter",
"types",
"(",
")",
"length",
"=",
"=",
"0",
"&",
"&",
"modifier",
"is",
"public",
"(",
"constructor",
"get",
"modifiers",
"(",
")",
")",
")",
"{",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}"
]
|
[
"get",
"task",
"finish",
"time",
"if",
"shuffle",
"finish",
"time",
"and",
"sort",
"finish",
"time",
"are",
"not",
"set",
"before",
",",
"these",
"are",
"set",
"to",
"finish",
"time",
"it",
"takes",
"care",
"of",
"the",
"case",
"when",
"shuffle",
",",
"sort",
"and",
"finish",
"are",
"completed",
"with",
"in",
"the",
"heartbeat",
"interval",
"and",
"are",
"not",
"reported",
"separately",
"if",
"task",
"state",
"is",
"task",
"status",
"failed",
"then",
"finish",
"time",
"represents",
"when",
"the",
"task",
"failed"
]
| [
"public",
"long",
"get",
"finish",
"time",
"(",
")",
"{",
"return",
"finish",
"time",
";",
"}"
]
|
[
"create",
"a",
"new",
"{",
"@",
"link",
"percentiles",
"}",
"aggregation",
"with",
"the",
"given",
"name"
]
| [
"public",
"static",
"percentiles",
"aggregation",
"builder",
"percentiles",
"(",
"string",
"name",
")",
"{",
"return",
"new",
"percentiles",
"aggregation",
"builder",
"(",
"name",
")",
";",
"}"
]
|
[
"whether",
"firstlast",
"visible",
"positions",
"should",
"be",
"updated",
"if",
"this",
"returns",
"true",
",",
"we",
"should",
"not",
"do",
"any",
"computations",
"based",
"on",
"current",
"firstlast",
"visible",
"positions",
"until",
"they",
"are",
"updated"
]
| [
"boolean",
"should",
"update",
"(",
")",
"{",
"return",
"m",
"current",
"first",
"visible",
"position",
"<",
"0",
"|",
"|",
"m",
"current",
"last",
"visible",
"position",
"<",
"0",
"|",
"|",
"m",
"should",
"update",
";",
"}"
]
|
[
"the",
"deserialized",
"response",
"body",
"of",
"a",
"{",
"@",
"linkplain",
"#",
"is",
"successful",
"(",
")",
"successful",
"}",
"response"
]
| [
"public",
"@",
"nullable",
"t",
"body",
"(",
")",
"{",
"return",
"body",
";",
"}"
]
|
[
"remove",
"the",
"given",
"block",
"pool",
"from",
"the",
"block",
"scanner",
",",
"dataset",
",",
"and",
"storage"
]
| [
"void",
"shutdown",
"block",
"pool",
"(",
"b",
"p",
"offer",
"service",
"bpos",
")",
"{",
"block",
"pool",
"manager",
"remove",
"(",
"bpos",
")",
";",
"if",
"(",
"bpos",
"has",
"block",
"pool",
"id",
"(",
")",
")",
"{",
"/",
"/",
"possible",
"that",
"this",
"is",
"shutting",
"down",
"before",
"successfully",
"/",
"/",
"registering",
"anywhere",
"if",
"that",
"'",
"s",
"the",
"case",
",",
"we",
"wouldn",
"'",
"t",
"have",
"/",
"/",
"a",
"block",
"pool",
"id",
"string",
"bp",
"id",
"=",
"bpos",
"get",
"block",
"pool",
"id",
"(",
")",
";",
"if",
"(",
"block",
"scanner",
"has",
"any",
"registered",
"scanner",
"(",
")",
")",
"{",
"block",
"scanner",
"disable",
"block",
"pool",
"id",
"(",
"bp",
"id",
")",
";",
"}",
"if",
"(",
"data",
"!",
"=",
"null",
")",
"{",
"data",
"shutdown",
"block",
"pool",
"(",
"bp",
"id",
")",
";",
"}",
"if",
"(",
"storage",
"!",
"=",
"null",
")",
"{",
"storage",
"remove",
"block",
"pool",
"storage",
"(",
"bp",
"id",
")",
";",
"}",
"}",
"}"
]
|
[
"returns",
"the",
"number",
"of",
"characters",
"that",
"can",
"be",
"held",
"without",
"growing"
]
| [
"public",
"int",
"capacity",
"(",
")",
"{",
"return",
"chars",
"length",
";",
"}"
]
|
[
"name",
"of",
"the",
"pet"
]
| [
"public",
"string",
"get",
"a",
"t",
"t",
"n",
"a",
"m",
"e",
"(",
")",
"{",
"return",
"att",
"name",
";",
"}"
]
|
[
"test",
"serialization",
"of",
"outer",
"boolean",
"types"
]
| [
"public",
"void",
"fake",
"outer",
"boolean",
"serialize",
"test",
"(",
")",
"throws",
"api",
"exception",
"{",
"boolean",
"body",
"=",
"null",
";",
"boolean",
"response",
"=",
"api",
"fake",
"outer",
"boolean",
"serialize",
"(",
"body",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
]
|
[
"releases",
"{",
"@",
"link",
"#",
"keep",
"session",
"id",
"audio",
"track",
"}",
"asynchronously",
",",
"if",
"it",
"is",
"non",
"-",
"{",
"@",
"code",
"null",
"}"
]
| [
"private",
"void",
"release",
"keep",
"session",
"id",
"audio",
"track",
"(",
")",
"{",
"if",
"(",
"keep",
"session",
"id",
"audio",
"track",
"=",
"=",
"null",
")",
"{",
"return",
";",
"}",
"/",
"/",
"audio",
"track",
"release",
"can",
"take",
"some",
"time",
",",
"so",
"we",
"call",
"it",
"on",
"a",
"background",
"thread",
"final",
"audio",
"track",
"to",
"release",
"=",
"keep",
"session",
"id",
"audio",
"track",
";",
"keep",
"session",
"id",
"audio",
"track",
"=",
"null",
";",
"new",
"thread",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"run",
"(",
")",
"{",
"to",
"release",
"release",
"(",
")",
";",
"}",
"}",
"start",
"(",
")",
";",
"}"
]
|
[
"block",
"on",
"the",
"completion",
"of",
"all",
"potentially",
"-",
"abandoned",
"background",
"tasks"
]
| [
"public",
"void",
"finish",
"background",
"tasks",
"(",
")",
"{",
"finish",
"background",
"tasks",
"(",
"glob",
"cache",
"values",
"(",
")",
")",
";",
"}"
]
|
[
"sends",
"a",
"dns",
"query",
"with",
"the",
"specified",
"question"
]
| [
"public",
"future",
"<",
"addressed",
"envelope",
"<",
"dns",
"response",
",",
"inet",
"socket",
"address",
">",
">",
"query",
"(",
"dns",
"question",
"question",
")",
"{",
"return",
"query",
"(",
"next",
"name",
"server",
"address",
"(",
")",
",",
"question",
")",
";",
"}"
]
|
[
"given",
"a",
"username",
"and",
"password",
",",
"open",
"a",
"connection",
"to",
"ldap",
",",
"bind",
"to",
"authenticate",
",",
"retrieve",
"groups",
",",
"map",
"to",
"roles",
"and",
"build",
"the",
"user",
"this",
"user",
"will",
"then",
"be",
"passed",
"to",
"the",
"listener"
]
| [
"protected",
"void",
"do",
"authenticate",
"(",
"username",
"password",
"token",
"token",
",",
"action",
"listener",
"<",
"authentication",
"result",
">",
"listener",
")",
"{",
"assert",
"delegated",
"realms",
"!",
"=",
"null",
":",
"\"",
"realm",
"has",
"not",
"been",
"initialized",
"correctly",
"\"",
";",
"/",
"/",
"we",
"submit",
"to",
"the",
"threadpool",
"because",
"authentication",
"using",
"ldap",
"will",
"execute",
"blocking",
"i",
"/",
"o",
"for",
"a",
"bind",
"request",
"and",
"we",
"don",
"'",
"t",
"want",
"/",
"/",
"network",
"threads",
"stuck",
"waiting",
"for",
"a",
"socket",
"to",
"connect",
"after",
"the",
"bind",
",",
"then",
"all",
"interaction",
"with",
"ldap",
"should",
"be",
"async",
"final",
"cancellable",
"ldap",
"runnable",
"<",
"authentication",
"result",
">",
"cancellable",
"ldap",
"runnable",
"=",
"new",
"cancellable",
"ldap",
"runnable",
"<",
">",
"(",
"listener",
",",
"ex",
"-",
">",
"authentication",
"result",
"unsuccessful",
"(",
"\"",
"authentication",
"against",
"realm",
"[",
"\"",
"+",
"this",
"to",
"string",
"(",
")",
"+",
"\"",
"]",
"failed",
"\"",
",",
"ex",
")",
",",
"(",
")",
"-",
">",
"session",
"factory",
"session",
"(",
"token",
"principal",
"(",
")",
",",
"token",
"credentials",
"(",
")",
",",
"context",
"preserving",
"listener",
"(",
"new",
"ldap",
"session",
"action",
"listener",
"(",
"\"",
"authenticate",
"\"",
",",
"token",
"principal",
"(",
")",
",",
"listener",
")",
")",
")",
",",
"logger",
")",
";",
"thread",
"pool",
"generic",
"(",
")",
"execute",
"(",
"cancellable",
"ldap",
"runnable",
")",
";",
"thread",
"pool",
"schedule",
"(",
"cancellable",
"ldap",
"runnable",
":",
":",
"maybe",
"timeout",
",",
"execution",
"timeout",
",",
"names",
"same",
")",
";",
"}"
]
|
[
"this",
"is",
"set",
"from",
"whatever",
"thread",
"model",
"building",
"happened",
"on",
",",
"so",
"must",
"be",
"thread",
"safe"
]
| [
"void",
"set",
"models",
"(",
"@",
"non",
"null",
"controller",
"model",
"list",
"models",
")",
"{",
"/",
"/",
"if",
"debug",
"model",
"validations",
"are",
"on",
"then",
"we",
"should",
"help",
"detect",
"the",
"error",
"case",
"where",
"models",
"/",
"/",
"were",
"incorrectly",
"mutated",
"once",
"they",
"were",
"added",
"that",
"check",
"is",
"also",
"done",
"before",
"and",
"after",
"/",
"/",
"bind",
",",
"but",
"there",
"is",
"no",
"other",
"check",
"after",
"that",
"to",
"see",
"if",
"a",
"model",
"is",
"incorrectly",
"/",
"/",
"mutated",
"after",
"being",
"bound",
"/",
"/",
"if",
"a",
"data",
"class",
"inside",
"a",
"model",
"is",
"mutated",
",",
"then",
"when",
"models",
"are",
"rebuilt",
"the",
"differ",
"/",
"/",
"will",
"still",
"recognize",
"the",
"old",
"and",
"new",
"models",
"as",
"equal",
",",
"even",
"though",
"the",
"old",
"model",
"was",
"changed",
"/",
"/",
"to",
"help",
"catch",
"that",
"error",
"case",
"we",
"check",
"for",
"mutations",
"here",
",",
"before",
"running",
"the",
"differ",
"/",
"/",
"/",
"/",
"https",
":",
"/",
"/",
"github",
"com",
"/",
"airbnb",
"/",
"epoxy",
"/",
"issues",
"/",
"805",
"list",
"<",
"?",
"extends",
"epoxy",
"model",
"<",
"?",
">",
">",
"current",
"models",
"=",
"get",
"current",
"models",
"(",
")",
";",
"if",
"(",
"!",
"current",
"models",
"is",
"empty",
"(",
")",
"&",
"&",
"current",
"models",
"get",
"(",
"0",
")",
"is",
"debug",
"validation",
"enabled",
"(",
")",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"current",
"models",
"size",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"epoxy",
"model",
"<",
"?",
">",
"model",
"=",
"current",
"models",
"get",
"(",
"i",
")",
";",
"model",
"validate",
"state",
"has",
"not",
"changed",
"since",
"added",
"(",
"\"",
"the",
"model",
"was",
"changed",
"between",
"being",
"bound",
"and",
"when",
"models",
"were",
"rebuilt",
"\"",
",",
"i",
")",
";",
"}",
"}",
"differ",
"submit",
"list",
"(",
"models",
")",
";",
"}"
]
|
[
"remove",
"the",
"index",
"resource",
"from",
"the",
"linked",
"list",
"indexed",
"by",
"list",
"i",
"d"
]
| [
"public",
"void",
"remove",
"(",
"int",
"list",
"i",
"d",
",",
"int",
"index",
")",
"{",
"if",
"(",
"(",
"list",
"i",
"d",
"<",
"0",
")",
"|",
"|",
"(",
"list",
"i",
"d",
">",
"=",
"num",
"lists",
")",
")",
"{",
"throw",
"new",
"index",
"out",
"of",
"bounds",
"exception",
"(",
"\"",
"the",
"list",
"i",
"d",
"is",
"out",
"of",
"bounds",
"\"",
")",
";",
"}",
"if",
"(",
"(",
"index",
"<",
"0",
")",
"|",
"|",
"(",
"index",
">",
"=",
"capacity",
")",
")",
"{",
"throw",
"new",
"index",
"out",
"of",
"bounds",
"exception",
"(",
")",
";",
"}",
"int",
"head",
"=",
"heads",
"[",
"list",
"i",
"d",
"]",
";",
"if",
"(",
"head",
"=",
"=",
"end",
"of",
"list",
")",
"{",
"return",
";",
"}",
"/",
"/",
"the",
"special",
"case",
"that",
"the",
"index",
"to",
"be",
"removed",
"is",
"the",
"first",
"one",
"in",
"/",
"/",
"the",
"list",
"if",
"(",
"head",
"=",
"=",
"index",
")",
"{",
"int",
"temp",
"=",
"links",
"[",
"head",
"]",
";",
"free",
"(",
"head",
")",
";",
"heads",
"[",
"list",
"i",
"d",
"]",
"=",
"temp",
";",
"return",
";",
"}",
"int",
"ptr",
"=",
"head",
";",
"/",
"/",
"search",
"for",
"the",
"index",
"in",
"the",
"list",
"if",
"the",
"end",
"of",
"the",
"list",
"is",
"/",
"/",
"reached",
",",
"then",
"the",
"index",
"is",
"not",
"in",
"the",
"list",
"and",
"we",
"don",
"'",
"t",
"care",
"while",
"(",
"links",
"[",
"ptr",
"]",
"!",
"=",
"end",
"of",
"list",
")",
"{",
"if",
"(",
"links",
"[",
"ptr",
"]",
"=",
"=",
"index",
")",
"{",
"/",
"/",
"found",
"the",
"index",
"to",
"be",
"deleted",
",",
"remove",
"it",
"from",
"the",
"list",
"by",
"/",
"/",
"fixing",
"the",
"preivous",
"index",
"'",
"s",
"link",
"to",
"skip",
"the",
"removed",
"index",
"links",
"[",
"ptr",
"]",
"=",
"links",
"[",
"index",
"]",
";",
"free",
"(",
"index",
")",
";",
"break",
";",
"}",
"ptr",
"=",
"links",
"[",
"ptr",
"]",
";",
"}",
"return",
";",
"}"
]
|
[
"get",
"the",
"erasure",
"coding",
"policy",
"if",
"it",
"'",
"s",
"set"
]
| [
"public",
"erasure",
"coding",
"policy",
"get",
"erasure",
"coding",
"policy",
"(",
")",
"{",
"return",
"ec",
"policy",
";",
"}"
]
|
[
"sets",
"the",
"<",
"code",
">",
"attribute",
"boolean",
"<",
"code",
">",
"property"
]
| [
"public",
"void",
"set",
"attribute",
"boolean",
"(",
"boolean",
"attribute",
"boolean",
")",
"{",
"this",
"attribute",
"boolean",
"=",
"attribute",
"boolean",
";",
"}"
]
|
[
"only",
"select",
"tasks",
"which",
"have",
"a",
"global",
"variable",
"value",
"greater",
"than",
"the",
"passed",
"value",
"when",
"they",
"ended",
"booleans",
",",
"byte",
"-",
"arrays",
"and",
"{",
"@",
"link",
"serializable",
"}",
"objects",
"(",
"which",
"are",
"not",
"primitive",
"type",
"wrappers",
")",
"are",
"not",
"supported"
]
| [
"t",
"process",
"variable",
"value",
"greater",
"than",
"(",
"string",
"name",
",",
"object",
"value",
")",
";"
]
|
[
"tests",
"that",
"cache",
"entries",
"are",
"cleaned",
"up",
"when",
"their",
"ttl",
"has",
"expired",
"upon",
"calling",
"{",
"@",
"link",
"default",
"execution",
"graph",
"cache",
"#",
"cleanup",
"(",
")",
"}"
]
| [
"public",
"void",
"test",
"cache",
"entry",
"cleanup",
"(",
")",
"throws",
"exception",
"{",
"final",
"time",
"timeout",
"=",
"time",
"milliseconds",
"(",
"100l",
")",
";",
"final",
"time",
"time",
"to",
"live",
"=",
"time",
"milliseconds",
"(",
"1l",
")",
";",
"final",
"job",
"i",
"d",
"expected",
"job",
"id",
"2",
"=",
"new",
"job",
"i",
"d",
"(",
")",
";",
"final",
"archived",
"execution",
"graph",
"expected",
"execution",
"graph",
"2",
"=",
"new",
"archived",
"execution",
"graph",
"builder",
"(",
")",
"build",
"(",
")",
";",
"final",
"atomic",
"integer",
"request",
"job",
"calls",
"=",
"new",
"atomic",
"integer",
"(",
"0",
")",
";",
"final",
"testing",
"restful",
"gateway",
"restful",
"gateway",
"=",
"new",
"testing",
"restful",
"gateway",
"builder",
"(",
")",
"set",
"request",
"job",
"function",
"(",
"job",
"id",
"-",
">",
"{",
"request",
"job",
"calls",
"increment",
"and",
"get",
"(",
")",
";",
"if",
"(",
"job",
"id",
"equals",
"(",
"expected",
"job",
"id",
")",
")",
"{",
"return",
"completable",
"future",
"completed",
"future",
"(",
"expected",
"execution",
"graph",
")",
";",
"}",
"else",
"if",
"(",
"job",
"id",
"equals",
"(",
"expected",
"job",
"id",
"2",
")",
")",
"{",
"return",
"completable",
"future",
"completed",
"future",
"(",
"expected",
"execution",
"graph",
"2",
")",
";",
"}",
"else",
"{",
"throw",
"new",
"assertion",
"error",
"(",
"\"",
"invalid",
"job",
"id",
"received",
"\"",
")",
";",
"}",
"}",
")",
"build",
"(",
")",
";",
"try",
"(",
"execution",
"graph",
"cache",
"execution",
"graph",
"cache",
"=",
"new",
"default",
"execution",
"graph",
"cache",
"(",
"timeout",
",",
"time",
"to",
"live",
")",
")",
"{",
"completable",
"future",
"<",
"access",
"execution",
"graph",
">",
"execution",
"graph",
"1",
"future",
"=",
"execution",
"graph",
"cache",
"get",
"execution",
"graph",
"(",
"expected",
"job",
"id",
",",
"restful",
"gateway",
")",
";",
"completable",
"future",
"<",
"access",
"execution",
"graph",
">",
"execution",
"graph",
"2",
"future",
"=",
"execution",
"graph",
"cache",
"get",
"execution",
"graph",
"(",
"expected",
"job",
"id",
"2",
",",
"restful",
"gateway",
")",
";",
"assert",
"equals",
"(",
"expected",
"execution",
"graph",
",",
"execution",
"graph",
"1",
"future",
"get",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"expected",
"execution",
"graph",
"2",
",",
"execution",
"graph",
"2",
"future",
"get",
"(",
")",
")",
";",
"assert",
"that",
"(",
"request",
"job",
"calls",
"get",
"(",
")",
",",
"matchers",
"equal",
"to",
"(",
"2",
")",
")",
";",
"thread",
"sleep",
"(",
"time",
"to",
"live",
"to",
"milliseconds",
"(",
")",
")",
";",
"execution",
"graph",
"cache",
"cleanup",
"(",
")",
";",
"assert",
"true",
"(",
"execution",
"graph",
"cache",
"size",
"(",
")",
"=",
"=",
"0",
")",
";",
"}",
"}"
]
|
[
"get",
"the",
"property",
"value"
]
| [
"public",
"string",
"get",
"property",
"(",
"string",
"key",
")",
"{",
"return",
"properties",
"get",
"(",
"key",
")",
";",
"}"
]
|
[
"query",
"minimum",
"offset",
"of",
"the",
"given",
"message",
"queue",
"this",
"method",
"will",
"be",
"removed",
"in",
"a",
"certain",
"version",
"after",
"april",
"5",
",",
"2020",
",",
"so",
"please",
"do",
"not",
"use",
"this",
"method"
]
| [
"public",
"long",
"min",
"offset",
"(",
"message",
"queue",
"mq",
")",
"throws",
"m",
"q",
"client",
"exception",
"{",
"return",
"this",
"default",
"m",
"q",
"producer",
"impl",
"min",
"offset",
"(",
"queue",
"with",
"namespace",
"(",
"mq",
")",
")",
";",
"}"
]
|
[
"resolves",
"the",
"requester",
"hostname",
"and",
"delegates",
"the",
"request",
"to",
"the",
"chain",
"the",
"requester",
"hostname",
"is",
"available",
"via",
"the",
"{",
"@",
"link",
"#",
"get",
"}",
"method"
]
| [
"public",
"void",
"do",
"filter",
"(",
"servlet",
"request",
"request",
",",
"servlet",
"response",
"response",
",",
"filter",
"chain",
"chain",
")",
"throws",
"i",
"o",
"exception",
",",
"servlet",
"exception",
"{",
"try",
"{",
"string",
"hostname",
";",
"try",
"{",
"string",
"address",
"=",
"request",
"get",
"remote",
"addr",
"(",
")",
";",
"if",
"(",
"address",
"!",
"=",
"null",
")",
"{",
"hostname",
"=",
"inet",
"address",
"get",
"by",
"name",
"(",
"address",
")",
"get",
"canonical",
"host",
"name",
"(",
")",
";",
"}",
"else",
"{",
"log",
"warn",
"(",
"\"",
"request",
"remote",
"address",
"is",
"null",
"\"",
")",
";",
"hostname",
"=",
"\"",
"?",
"?",
"?",
"\"",
";",
"}",
"}",
"catch",
"(",
"unknown",
"host",
"exception",
"ex",
")",
"{",
"log",
"warn",
"(",
"\"",
"request",
"remote",
"address",
"could",
"not",
"be",
"resolved",
",",
"{",
"0",
"}",
"\"",
",",
"ex",
"to",
"string",
"(",
")",
",",
"ex",
")",
";",
"hostname",
"=",
"\"",
"?",
"?",
"?",
"\"",
";",
"}",
"hostname",
"tl",
"set",
"(",
"hostname",
")",
";",
"chain",
"do",
"filter",
"(",
"request",
",",
"response",
")",
";",
"}",
"finally",
"{",
"hostname",
"tl",
"remove",
"(",
")",
";",
"}",
"}"
]
|
[
"return",
"the",
"assigned",
"{",
"@",
"link",
"channel",
"pipeline",
"}"
]
| [
"channel",
"pipeline",
"pipeline",
"(",
")",
";"
]
|
[
"returns",
"the",
"bit",
"offset",
"from",
"the",
"register",
"address",
"for",
"this",
"register"
]
| [
"public",
"int",
"get",
"least",
"significant",
"bit",
"(",
")",
"{",
"return",
"least",
"sig",
"bit",
";",
"}"
]
|
[
"create",
"a",
"jms",
"message",
"consumer",
"for",
"the",
"given",
"session",
"and",
"destination",
"this",
"implementation",
"uses",
"jms",
"1",
"1",
"api"
]
| [
"protected",
"message",
"consumer",
"create",
"consumer",
"(",
"session",
"session",
",",
"destination",
"destination",
")",
"throws",
"j",
"m",
"s",
"exception",
"{",
"if",
"(",
"is",
"pub",
"sub",
"domain",
"(",
")",
"&",
"&",
"destination",
"instanceof",
"topic",
")",
"{",
"if",
"(",
"is",
"subscription",
"shared",
"(",
")",
")",
"{",
"return",
"(",
"is",
"subscription",
"durable",
"(",
")",
"?",
"session",
"create",
"shared",
"durable",
"consumer",
"(",
"(",
"topic",
")",
"destination",
",",
"get",
"subscription",
"name",
"(",
")",
",",
"get",
"message",
"selector",
"(",
")",
")",
":",
"session",
"create",
"shared",
"consumer",
"(",
"(",
"topic",
")",
"destination",
",",
"get",
"subscription",
"name",
"(",
")",
",",
"get",
"message",
"selector",
"(",
")",
")",
")",
";",
"}",
"else",
"if",
"(",
"is",
"subscription",
"durable",
"(",
")",
")",
"{",
"return",
"session",
"create",
"durable",
"subscriber",
"(",
"(",
"topic",
")",
"destination",
",",
"get",
"subscription",
"name",
"(",
")",
",",
"get",
"message",
"selector",
"(",
")",
",",
"is",
"pub",
"sub",
"no",
"local",
"(",
")",
")",
";",
"}",
"else",
"{",
"/",
"/",
"only",
"pass",
"in",
"the",
"no",
"local",
"flag",
"in",
"case",
"of",
"a",
"topic",
"(",
"pub",
"-",
"sub",
"mode",
")",
":",
"/",
"/",
"some",
"jms",
"providers",
",",
"such",
"as",
"web",
"sphere",
"mq",
"6",
"0",
",",
"throw",
"illegal",
"state",
"exception",
"/",
"/",
"in",
"case",
"of",
"the",
"no",
"local",
"flag",
"being",
"specified",
"for",
"a",
"queue",
"return",
"session",
"create",
"consumer",
"(",
"destination",
",",
"get",
"message",
"selector",
"(",
")",
",",
"is",
"pub",
"sub",
"no",
"local",
"(",
")",
")",
";",
"}",
"}",
"else",
"{",
"return",
"session",
"create",
"consumer",
"(",
"destination",
",",
"get",
"message",
"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",
";",
"}"
]
|
[
"update",
"the",
"dictionary"
]
| [
"public",
"void",
"set",
"dictionary",
"(",
"dictionary",
"dictionary",
")",
"{",
"this",
"dictionary",
"=",
"dictionary",
";",
"}"
]
|
[
"read",
"the",
"int",
"value"
]
| [
"static",
"int",
"read",
"int",
"(",
"data",
"input",
"in",
")",
"throws",
"i",
"o",
"exception",
"{",
"int",
"writable",
"u",
"int",
"=",
"tl",
"data",
"get",
"(",
")",
"u",
"int",
";",
"u",
"int",
"read",
"fields",
"(",
"in",
")",
";",
"return",
"u",
"int",
"get",
"(",
")",
";",
"}"
]
|
[
"set",
"whether",
"to",
"allow",
"for",
"a",
"local",
"jms",
"transaction",
"that",
"is",
"synchronized",
"with",
"a",
"spring",
"-",
"managed",
"transaction",
"(",
"where",
"the",
"main",
"transaction",
"might",
"be",
"a",
"jdbc",
"-",
"based",
"one",
"for",
"a",
"specific",
"data",
"source",
",",
"for",
"example",
")",
",",
"with",
"the",
"jms",
"transaction",
"committing",
"right",
"after",
"the",
"main",
"transaction",
"if",
"not",
"allowed",
",",
"the",
"given",
"connection",
"factory",
"needs",
"to",
"handle",
"transaction",
"enlistment",
"underneath",
"the",
"covers",
"default",
"is",
"\"",
"false",
"\"",
":",
"if",
"not",
"within",
"a",
"managed",
"transaction",
"that",
"encompasses",
"the",
"underlying",
"jms",
"connection",
"factory",
",",
"standard",
"sessions",
"will",
"be",
"returned",
"turn",
"this",
"flag",
"on",
"to",
"allow",
"participation",
"in",
"any",
"spring",
"-",
"managed",
"transaction",
",",
"with",
"a",
"local",
"jms",
"transaction",
"synchronized",
"with",
"the",
"main",
"transaction"
]
| [
"public",
"void",
"set",
"synched",
"local",
"transaction",
"allowed",
"(",
"boolean",
"synched",
"local",
"transaction",
"allowed",
")",
"{",
"this",
"synched",
"local",
"transaction",
"allowed",
"=",
"synched",
"local",
"transaction",
"allowed",
";",
"}"
]
|
[
"the",
"value",
"of",
"the",
"handler",
"pc",
"item",
"indicates",
"the",
"start",
"of",
"the",
"exception",
"handler",
"the",
"value",
"of",
"the",
"item",
"must",
"be",
"a",
"valid",
"index",
"into",
"the",
"code",
"array",
"and",
"must",
"be",
"the",
"index",
"of",
"the",
"opcode",
"of",
"an",
"instruction"
]
| [
"public",
"int",
"get",
"handler",
"p",
"c",
"(",
")",
"{",
"return",
"handler",
"p",
"c",
"&",
"0xffff",
";",
"}"
]
|
[
"returns",
"the",
"flavor",
"of",
"the",
"rule",
"(",
"true",
"for",
"4",
"operands",
",",
"false",
"for",
"3",
"operands",
")"
]
| [
"boolean",
"flavor",
"(",
")",
";"
]
|
[
"name",
"of",
"the",
"pet"
]
| [
"public",
"capitalization",
"att",
"name",
"(",
"string",
"att",
"name",
")",
"{",
"this",
"att",
"name",
"=",
"att",
"name",
";",
"return",
"this",
";",
"}"
]
|
[
"returns",
"the",
"<",
"a",
"href",
"=",
"\"",
"http",
":",
"en",
"wikipedia",
"orgwiki",
"standard",
"deviation",
"#",
"corrected",
"sample",
"standard",
"deviation",
"\"",
">",
"corrected",
"sample",
"standard",
"deviation",
"of",
"the",
"values",
"if",
"this",
"dataset",
"is",
"a",
"sample",
"drawn",
"from",
"a",
"population",
",",
"this",
"is",
"an",
"estimator",
"of",
"the",
"population",
"standard",
"deviation",
"of",
"the",
"population",
"which",
"is",
"less",
"biased",
"than",
"{",
"@",
"link",
"#",
"population",
"standard",
"deviation",
"(",
")",
"}",
"(",
"the",
"unbiased",
"estimator",
"depends",
"on",
"the",
"distribution",
")",
"the",
"count",
"must",
"be",
"greater",
"than",
"one",
"this",
"is",
"not",
"guaranteed",
"to",
"return",
"zero",
"when",
"the",
"dataset",
"consists",
"of",
"the",
"same",
"value",
"multiple",
"times",
",",
"due",
"to",
"numerical",
"errors",
"however",
",",
"it",
"is",
"guaranteed",
"never",
"to",
"return",
"a",
"negative",
"result",
"<",
"h",
"3",
">",
"non",
"-",
"finite",
"values",
"<",
"h",
"3",
">",
"if",
"the",
"dataset",
"contains",
"any",
"non",
"-",
"finite",
"values",
"(",
"{",
"@",
"link",
"double",
"#",
"positive",
"infinity",
"}",
",",
"{",
"@",
"link",
"double",
"#",
"negative",
"infinity",
"}",
",",
"or",
"{",
"@",
"link",
"double",
"#",
"na",
"n",
"}",
")",
"then",
"the",
"result",
"is",
"{",
"@",
"link",
"double",
"#",
"na",
"n",
"}"
]
| [
"public",
"double",
"sample",
"standard",
"deviation",
"(",
")",
"{",
"return",
"math",
"sqrt",
"(",
"sample",
"variance",
"(",
")",
")",
";",
"}"
]
|
[
"set",
"the",
"value",
"of",
"the",
"'",
"{",
"@",
"code",
"autocomplete",
"}",
"'",
"attribute",
"may",
"be",
"a",
"runtime",
"expression"
]
| [
"public",
"void",
"set",
"autocomplete",
"(",
"string",
"autocomplete",
")",
"{",
"this",
"autocomplete",
"=",
"autocomplete",
";",
"}"
]
|
[
"creates",
"a",
"{",
"@",
"link",
"sink",
"function",
"}",
"instance"
]
| [
"sink",
"function",
"<",
"row",
"data",
">",
"create",
"sink",
"function",
"(",
")",
";"
]
|
[
"called",
"to",
"process",
"media",
"key",
"events",
"any",
"{",
"@",
"link",
"key",
"event",
"}",
"can",
"be",
"passed",
"but",
"only",
"media",
"key",
"events",
"will",
"be",
"handled",
"does",
"nothing",
"if",
"playback",
"controls",
"are",
"disabled"
]
| [
"public",
"boolean",
"dispatch",
"media",
"key",
"event",
"(",
"key",
"event",
"event",
")",
"{",
"return",
"use",
"controller",
"(",
")",
"&",
"&",
"controller",
"dispatch",
"media",
"key",
"event",
"(",
"event",
")",
";",
"}"
]
|
[
"set",
"the",
"deliver"
]
| [
"public",
"static",
"void",
"set",
"deliver",
"(",
"final",
"executor",
"deliver",
")",
"{",
"s",
"deliver",
"=",
"deliver",
";",
"}"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.