docstring_tokens
list | code_tokens
list |
|---|---|
[
"create",
"a",
"proxy",
"for",
"the",
"specified",
"{",
"@",
"link",
"connection",
"}",
"instance"
] |
[
"static",
"proxy",
"connection",
"get",
"proxy",
"connection",
"(",
"final",
"pool",
"entry",
"pool",
"entry",
",",
"final",
"connection",
"connection",
",",
"final",
"fast",
"list",
"<",
"statement",
">",
"open",
"statements",
",",
"final",
"proxy",
"leak",
"task",
"leak",
"task",
",",
"final",
"long",
"now",
",",
"final",
"boolean",
"is",
"read",
"only",
",",
"final",
"boolean",
"is",
"auto",
"commit",
")",
"{",
"/",
"/",
"body",
"is",
"replaced",
"(",
"injected",
")",
"by",
"javassist",
"proxy",
"factory",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"you",
"need",
"to",
"run",
"the",
"cli",
"build",
"and",
"you",
"need",
"target",
"/",
"classes",
"in",
"your",
"classpath",
"to",
"run",
"\"",
")",
";",
"}"
] |
[
"determine",
"if",
"a",
"stream",
"can",
"do",
"a",
"byte",
"buffer",
"read",
"via",
"read",
"(",
"byte",
"buffer",
"buf",
")"
] |
[
"private",
"static",
"boolean",
"stream",
"has",
"byte",
"buffer",
"read",
"(",
"input",
"stream",
"stream",
")",
"{",
"if",
"(",
"!",
"(",
"stream",
"instanceof",
"byte",
"buffer",
"readable",
")",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"!",
"(",
"stream",
"instanceof",
"f",
"s",
"data",
"input",
"stream",
")",
")",
"{",
"return",
"true",
";",
"}",
"return",
"(",
"(",
"f",
"s",
"data",
"input",
"stream",
")",
"stream",
")",
"get",
"wrapped",
"stream",
"(",
")",
"instanceof",
"byte",
"buffer",
"readable",
";",
"}"
] |
[
"callback",
"that",
"supplies",
"the",
"bean",
"{",
"@",
"link",
"class",
"loader",
"class",
"loader",
"}",
"to",
"a",
"bean",
"instance",
"invoked",
"after",
"the",
"population",
"of",
"normal",
"bean",
"properties",
"but",
"before",
"an",
"initialization",
"callback",
"such",
"as",
"{",
"@",
"link",
"initializing",
"bean",
"initializing",
"bean",
"'",
"s",
"}",
"{",
"@",
"link",
"initializing",
"bean",
"#",
"after",
"properties",
"set",
"(",
")",
"}",
"method",
"or",
"a",
"custom",
"init",
"-",
"method"
] |
[
"void",
"set",
"bean",
"class",
"loader",
"(",
"class",
"loader",
"class",
"loader",
")",
";"
] |
[
"make",
"sure",
"that",
"a",
"request",
"using",
"a",
"deterministic",
"script",
"or",
"not",
"using",
"a",
"script",
"get",
"cached",
"ensure",
"requests",
"using",
"nondeterministic",
"scripts",
"do",
"not",
"get",
"cached"
] |
[
"public",
"void",
"test",
"script",
"caching",
"(",
")",
"throws",
"exception",
"{",
"assert",
"acked",
"(",
"prepare",
"create",
"(",
"\"",
"cache",
"test",
"idx",
"\"",
")",
"set",
"mapping",
"(",
"\"",
"d",
"\"",
",",
"\"",
"type",
"=",
"long",
"\"",
")",
"set",
"settings",
"(",
"settings",
"builder",
"(",
")",
"put",
"(",
"\"",
"requests",
"cache",
"enable",
"\"",
",",
"true",
")",
"put",
"(",
"\"",
"number",
"of",
"shards",
"\"",
",",
"1",
")",
"put",
"(",
"\"",
"number",
"of",
"replicas",
"\"",
",",
"1",
")",
")",
"get",
"(",
")",
")",
";",
"index",
"random",
"(",
"true",
",",
"client",
"(",
")",
"prepare",
"index",
"(",
"\"",
"cache",
"test",
"idx",
"\"",
")",
"set",
"id",
"(",
"\"",
"1",
"\"",
")",
"set",
"source",
"(",
"\"",
"s",
"\"",
",",
"1",
")",
",",
"client",
"(",
")",
"prepare",
"index",
"(",
"\"",
"cache",
"test",
"idx",
"\"",
")",
"set",
"id",
"(",
"\"",
"2",
"\"",
")",
"set",
"source",
"(",
"\"",
"s",
"\"",
",",
"2",
")",
")",
";",
"/",
"/",
"make",
"sure",
"we",
"are",
"starting",
"with",
"a",
"clear",
"cache",
"assert",
"that",
"(",
"client",
"(",
")",
"admin",
"(",
")",
"indices",
"(",
")",
"prepare",
"stats",
"(",
"\"",
"cache",
"test",
"idx",
"\"",
")",
"set",
"request",
"cache",
"(",
"true",
")",
"get",
"(",
")",
"get",
"total",
"(",
")",
"get",
"request",
"cache",
"(",
")",
"get",
"hit",
"count",
"(",
")",
",",
"equal",
"to",
"(",
"0l",
")",
")",
";",
"assert",
"that",
"(",
"client",
"(",
")",
"admin",
"(",
")",
"indices",
"(",
")",
"prepare",
"stats",
"(",
"\"",
"cache",
"test",
"idx",
"\"",
")",
"set",
"request",
"cache",
"(",
"true",
")",
"get",
"(",
")",
"get",
"total",
"(",
")",
"get",
"request",
"cache",
"(",
")",
"get",
"miss",
"count",
"(",
")",
",",
"equal",
"to",
"(",
"0l",
")",
")",
";",
"/",
"/",
"test",
"that",
"a",
"request",
"using",
"a",
"nondeterministic",
"script",
"does",
"not",
"get",
"cached",
"search",
"response",
"r",
"=",
"client",
"(",
")",
"prepare",
"search",
"(",
"\"",
"cache",
"test",
"idx",
"\"",
")",
"set",
"size",
"(",
"0",
")",
"add",
"aggregation",
"(",
"percentiles",
"(",
"\"",
"foo",
"\"",
")",
"method",
"(",
"percentiles",
"method",
"hdr",
")",
"field",
"(",
"\"",
"d",
"\"",
")",
"percentiles",
"(",
"50",
"0",
")",
"script",
"(",
"new",
"script",
"(",
"script",
"type",
"inline",
",",
"aggregation",
"test",
"scripts",
"plugin",
"name",
",",
"\"",
"math",
"random",
"(",
")",
"\"",
",",
"empty",
"map",
"(",
")",
")",
")",
")",
"get",
"(",
")",
";",
"assert",
"search",
"response",
"(",
"r",
")",
";",
"assert",
"that",
"(",
"client",
"(",
")",
"admin",
"(",
")",
"indices",
"(",
")",
"prepare",
"stats",
"(",
"\"",
"cache",
"test",
"idx",
"\"",
")",
"set",
"request",
"cache",
"(",
"true",
")",
"get",
"(",
")",
"get",
"total",
"(",
")",
"get",
"request",
"cache",
"(",
")",
"get",
"hit",
"count",
"(",
")",
",",
"equal",
"to",
"(",
"0l",
")",
")",
";",
"assert",
"that",
"(",
"client",
"(",
")",
"admin",
"(",
")",
"indices",
"(",
")",
"prepare",
"stats",
"(",
"\"",
"cache",
"test",
"idx",
"\"",
")",
"set",
"request",
"cache",
"(",
"true",
")",
"get",
"(",
")",
"get",
"total",
"(",
")",
"get",
"request",
"cache",
"(",
")",
"get",
"miss",
"count",
"(",
")",
",",
"equal",
"to",
"(",
"0l",
")",
")",
";",
"/",
"/",
"test",
"that",
"a",
"request",
"using",
"a",
"deterministic",
"script",
"gets",
"cached",
"r",
"=",
"client",
"(",
")",
"prepare",
"search",
"(",
"\"",
"cache",
"test",
"idx",
"\"",
")",
"set",
"size",
"(",
"0",
")",
"add",
"aggregation",
"(",
"percentiles",
"(",
"\"",
"foo",
"\"",
")",
"method",
"(",
"percentiles",
"method",
"hdr",
")",
"field",
"(",
"\"",
"d",
"\"",
")",
"percentiles",
"(",
"50",
"0",
")",
"script",
"(",
"new",
"script",
"(",
"script",
"type",
"inline",
",",
"aggregation",
"test",
"scripts",
"plugin",
"name",
",",
"\"",
"value",
"-",
"1",
"\"",
",",
"empty",
"map",
"(",
")",
")",
")",
")",
"get",
"(",
")",
";",
"assert",
"search",
"response",
"(",
"r",
")",
";",
"assert",
"that",
"(",
"client",
"(",
")",
"admin",
"(",
")",
"indices",
"(",
")",
"prepare",
"stats",
"(",
"\"",
"cache",
"test",
"idx",
"\"",
")",
"set",
"request",
"cache",
"(",
"true",
")",
"get",
"(",
")",
"get",
"total",
"(",
")",
"get",
"request",
"cache",
"(",
")",
"get",
"hit",
"count",
"(",
")",
",",
"equal",
"to",
"(",
"0l",
")",
")",
";",
"assert",
"that",
"(",
"client",
"(",
")",
"admin",
"(",
")",
"indices",
"(",
")",
"prepare",
"stats",
"(",
"\"",
"cache",
"test",
"idx",
"\"",
")",
"set",
"request",
"cache",
"(",
"true",
")",
"get",
"(",
")",
"get",
"total",
"(",
")",
"get",
"request",
"cache",
"(",
")",
"get",
"miss",
"count",
"(",
")",
",",
"equal",
"to",
"(",
"1l",
")",
")",
";",
"/",
"/",
"ensure",
"that",
"non",
"-",
"scripted",
"requests",
"are",
"cached",
"as",
"normal",
"r",
"=",
"client",
"(",
")",
"prepare",
"search",
"(",
"\"",
"cache",
"test",
"idx",
"\"",
")",
"set",
"size",
"(",
"0",
")",
"add",
"aggregation",
"(",
"percentiles",
"(",
"\"",
"foo",
"\"",
")",
"method",
"(",
"percentiles",
"method",
"hdr",
")",
"field",
"(",
"\"",
"d",
"\"",
")",
"percentiles",
"(",
"50",
"0",
")",
")",
"get",
"(",
")",
";",
"assert",
"search",
"response",
"(",
"r",
")",
";",
"assert",
"that",
"(",
"client",
"(",
")",
"admin",
"(",
")",
"indices",
"(",
")",
"prepare",
"stats",
"(",
"\"",
"cache",
"test",
"idx",
"\"",
")",
"set",
"request",
"cache",
"(",
"true",
")",
"get",
"(",
")",
"get",
"total",
"(",
")",
"get",
"request",
"cache",
"(",
")",
"get",
"hit",
"count",
"(",
")",
",",
"equal",
"to",
"(",
"0l",
")",
")",
";",
"assert",
"that",
"(",
"client",
"(",
")",
"admin",
"(",
")",
"indices",
"(",
")",
"prepare",
"stats",
"(",
"\"",
"cache",
"test",
"idx",
"\"",
")",
"set",
"request",
"cache",
"(",
"true",
")",
"get",
"(",
")",
"get",
"total",
"(",
")",
"get",
"request",
"cache",
"(",
")",
"get",
"miss",
"count",
"(",
")",
",",
"equal",
"to",
"(",
"2l",
")",
")",
";",
"}"
] |
[
"sets",
"two",
"distinct",
"values",
"for",
"{",
"@",
"code",
"type",
"}",
"these",
"values",
"can",
"be",
"used",
"for",
"both",
"null",
"pointer",
"testing",
"and",
"equals",
"testing"
] |
[
"protected",
"final",
"<",
"t",
">",
"void",
"set",
"distinct",
"values",
"(",
"class",
"<",
"t",
">",
"type",
",",
"t",
"value",
"1",
",",
"t",
"value",
"2",
")",
"{",
"tester",
"set",
"distinct",
"values",
"(",
"type",
",",
"value",
"1",
",",
"value",
"2",
")",
";",
"}"
] |
[
"if",
"false",
",",
"methods",
"that",
"change",
"the",
"text",
"will",
"not",
"fire",
"{",
"@",
"link",
"change",
"event",
"}",
",",
"the",
"event",
"will",
"be",
"fired",
"only",
"when",
"the",
"user",
"changes",
"the",
"text"
] |
[
"public",
"void",
"set",
"programmatic",
"change",
"events",
"(",
"boolean",
"programmatic",
"change",
"events",
")",
"{",
"this",
"programmatic",
"change",
"events",
"=",
"programmatic",
"change",
"events",
";",
"}"
] |
[
"gets",
"the",
"preferred",
"successor",
"for",
"the",
"given",
"block",
"if",
"the",
"block",
"only",
"has",
"one",
"successor",
",",
"then",
"that",
"is",
"the",
"preferred",
"successor",
"otherwise",
",",
"if",
"the",
"block",
"has",
"a",
"primay",
"successor",
",",
"then",
"that",
"is",
"the",
"preferred",
"successor",
"if",
"the",
"block",
"has",
"no",
"successors",
",",
"then",
"this",
"returns",
"{",
"@",
"code",
"null",
"}"
] |
[
"public",
"basic",
"block",
"preferred",
"successor",
"of",
"(",
"basic",
"block",
"block",
")",
"{",
"int",
"primary",
"successor",
"=",
"block",
"get",
"primary",
"successor",
"(",
")",
";",
"int",
"list",
"successors",
"=",
"block",
"get",
"successors",
"(",
")",
";",
"int",
"succ",
"size",
"=",
"successors",
"size",
"(",
")",
";",
"switch",
"(",
"succ",
"size",
")",
"{",
"case",
"0",
":",
"{",
"return",
"null",
";",
"}",
"case",
"1",
":",
"{",
"return",
"label",
"to",
"block",
"(",
"successors",
"get",
"(",
"0",
")",
")",
";",
"}",
"}",
"if",
"(",
"primary",
"successor",
"!",
"=",
"-",
"1",
")",
"{",
"return",
"label",
"to",
"block",
"(",
"primary",
"successor",
")",
";",
"}",
"else",
"{",
"return",
"label",
"to",
"block",
"(",
"successors",
"get",
"(",
"0",
")",
")",
";",
"}",
"}"
] |
[
"start",
"the",
"connector",
"server",
"if",
"the",
"{",
"@",
"code",
"threaded",
"}",
"flag",
"is",
"set",
"to",
"{",
"@",
"code",
"true",
"}",
",",
"the",
"{",
"@",
"code",
"j",
"m",
"x",
"connector",
"server",
"}",
"will",
"be",
"started",
"in",
"a",
"separate",
"thread",
"if",
"the",
"{",
"@",
"code",
"daemon",
"}",
"flag",
"is",
"set",
"to",
"{",
"@",
"code",
"true",
"}",
",",
"that",
"thread",
"will",
"be",
"started",
"as",
"a",
"daemon",
"thread"
] |
[
"public",
"void",
"after",
"properties",
"set",
"(",
")",
"throws",
"j",
"m",
"exception",
",",
"i",
"o",
"exception",
"{",
"if",
"(",
"this",
"server",
"=",
"=",
"null",
")",
"{",
"this",
"server",
"=",
"jmx",
"utils",
"locate",
"m",
"bean",
"server",
"(",
")",
";",
"}",
"/",
"/",
"create",
"the",
"jmx",
"service",
"url",
"j",
"m",
"x",
"service",
"u",
"r",
"l",
"url",
"=",
"new",
"j",
"m",
"x",
"service",
"u",
"r",
"l",
"(",
"this",
"service",
"url",
")",
";",
"/",
"/",
"create",
"the",
"connector",
"server",
"now",
"this",
"connector",
"server",
"=",
"j",
"m",
"x",
"connector",
"server",
"factory",
"new",
"j",
"m",
"x",
"connector",
"server",
"(",
"url",
",",
"this",
"environment",
",",
"this",
"server",
")",
";",
"/",
"/",
"set",
"the",
"given",
"m",
"bean",
"server",
"forwarder",
",",
"if",
"any",
"if",
"(",
"this",
"forwarder",
"!",
"=",
"null",
")",
"{",
"this",
"connector",
"server",
"set",
"m",
"bean",
"server",
"forwarder",
"(",
"this",
"forwarder",
")",
";",
"}",
"/",
"/",
"do",
"we",
"want",
"to",
"register",
"the",
"connector",
"with",
"the",
"m",
"bean",
"server",
"?",
"if",
"(",
"this",
"object",
"name",
"!",
"=",
"null",
")",
"{",
"do",
"register",
"(",
"this",
"connector",
"server",
",",
"this",
"object",
"name",
")",
";",
"}",
"try",
"{",
"if",
"(",
"this",
"threaded",
")",
"{",
"/",
"/",
"start",
"the",
"connector",
"server",
"asynchronously",
"(",
"in",
"a",
"separate",
"thread",
")",
"final",
"j",
"m",
"x",
"connector",
"server",
"server",
"to",
"start",
"=",
"this",
"connector",
"server",
";",
"thread",
"connector",
"thread",
"=",
"new",
"thread",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"run",
"(",
")",
"{",
"try",
"{",
"server",
"to",
"start",
"start",
"(",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ex",
")",
"{",
"throw",
"new",
"jmx",
"exception",
"(",
"\"",
"could",
"not",
"start",
"jmx",
"connector",
"server",
"after",
"delay",
"\"",
",",
"ex",
")",
";",
"}",
"}",
"}",
";",
"connector",
"thread",
"set",
"name",
"(",
"\"",
"jmx",
"connector",
"thread",
"[",
"\"",
"+",
"this",
"service",
"url",
"+",
"\"",
"]",
"\"",
")",
";",
"connector",
"thread",
"set",
"daemon",
"(",
"this",
"daemon",
")",
";",
"connector",
"thread",
"start",
"(",
")",
";",
"}",
"else",
"{",
"/",
"/",
"start",
"the",
"connector",
"server",
"in",
"the",
"same",
"thread",
"this",
"connector",
"server",
"start",
"(",
")",
";",
"}",
"if",
"(",
"logger",
"is",
"info",
"enabled",
"(",
")",
")",
"{",
"logger",
"info",
"(",
"\"",
"jmx",
"connector",
"server",
"started",
":",
"\"",
"+",
"this",
"connector",
"server",
")",
";",
"}",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ex",
")",
"{",
"/",
"/",
"unregister",
"the",
"connector",
"server",
"if",
"startup",
"failed",
"unregister",
"beans",
"(",
")",
";",
"throw",
"ex",
";",
"}",
"}"
] |
[
"get",
"the",
"status",
"code"
] |
[
"public",
"int",
"get",
"status",
"code",
"(",
")",
"{",
"return",
"status",
"code",
";",
"}"
] |
[
"get",
"the",
"application",
"attempt",
"id",
"for",
"this",
"job"
] |
[
"public",
"static",
"int",
"get",
"app",
"attempt",
"id",
"(",
"job",
"context",
"context",
")",
"{",
"return",
"context",
"get",
"configuration",
"(",
")",
"get",
"int",
"(",
"m",
"r",
"job",
"config",
"application",
"attempt",
"id",
",",
"0",
")",
";",
"}"
] |
[
"tells",
"whether",
"the",
"target",
"is",
"a",
"microsoft",
"intermediate",
"language",
"netmodule"
] |
[
"public",
"boolean",
"is",
"microsoft",
"intermediate",
"language",
"net",
"module",
"(",
")",
"{",
"return",
"microsoft",
"intermediate",
"language",
"net",
"module",
";",
"}"
] |
[
"build",
"call",
"for",
"test",
"classname"
] |
[
"public",
"okhttp",
"3",
"call",
"test",
"classname",
"call",
"(",
"client",
"body",
",",
"final",
"api",
"callback",
"callback",
")",
"throws",
"api",
"exception",
"{",
"object",
"local",
"var",
"post",
"body",
"=",
"body",
";",
"/",
"/",
"create",
"path",
"and",
"map",
"variables",
"string",
"local",
"var",
"path",
"=",
"\"",
"/",
"fake",
"classname",
"test",
"\"",
";",
"list",
"<",
"pair",
">",
"local",
"var",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"list",
"<",
"pair",
">",
"local",
"var",
"collection",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"header",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"cookie",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"object",
">",
"local",
"var",
"form",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"final",
"string",
"[",
"]",
"local",
"var",
"accepts",
"=",
"{",
"\"",
"application",
"/",
"json",
"\"",
"}",
";",
"final",
"string",
"local",
"var",
"accept",
"=",
"local",
"var",
"api",
"client",
"select",
"header",
"accept",
"(",
"local",
"var",
"accepts",
")",
";",
"if",
"(",
"local",
"var",
"accept",
"!",
"=",
"null",
")",
"{",
"local",
"var",
"header",
"params",
"put",
"(",
"\"",
"accept",
"\"",
",",
"local",
"var",
"accept",
")",
";",
"}",
"final",
"string",
"[",
"]",
"local",
"var",
"content",
"types",
"=",
"{",
"\"",
"application",
"/",
"json",
"\"",
"}",
";",
"final",
"string",
"local",
"var",
"content",
"type",
"=",
"local",
"var",
"api",
"client",
"select",
"header",
"content",
"type",
"(",
"local",
"var",
"content",
"types",
")",
";",
"local",
"var",
"header",
"params",
"put",
"(",
"\"",
"content",
"-",
"type",
"\"",
",",
"local",
"var",
"content",
"type",
")",
";",
"string",
"[",
"]",
"local",
"var",
"auth",
"names",
"=",
"new",
"string",
"[",
"]",
"{",
"\"",
"api",
"key",
"query",
"\"",
"}",
";",
"return",
"local",
"var",
"api",
"client",
"build",
"call",
"(",
"local",
"var",
"path",
",",
"\"",
"patch",
"\"",
",",
"local",
"var",
"query",
"params",
",",
"local",
"var",
"collection",
"query",
"params",
",",
"local",
"var",
"post",
"body",
",",
"local",
"var",
"header",
"params",
",",
"local",
"var",
"cookie",
"params",
",",
"local",
"var",
"form",
"params",
",",
"local",
"var",
"auth",
"names",
",",
"callback",
")",
";",
"}"
] |
[
"delete",
"a",
"record",
"identified",
"by",
"the",
"specified",
"key",
"value"
] |
[
"public",
"boolean",
"delete",
"record",
"(",
"field",
"key",
")",
"throws",
"i",
"o",
"exception",
"{",
"synchronized",
"(",
"db",
")",
"{",
"db",
"check",
"transaction",
"(",
")",
";",
"boolean",
"result",
"=",
"false",
";",
"if",
"(",
"root",
"buffer",
"id",
"<",
"0",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"key",
"instanceof",
"long",
"field",
")",
"{",
"return",
"delete",
"record",
"(",
"key",
"get",
"long",
"value",
"(",
")",
")",
";",
"}",
"try",
"{",
"+",
"+",
"mod",
"count",
";",
"field",
"key",
"node",
"root",
"node",
"=",
"get",
"field",
"key",
"node",
"(",
"root",
"buffer",
"id",
")",
";",
"field",
"key",
"record",
"node",
"leaf",
"=",
"root",
"node",
"get",
"leaf",
"node",
"(",
"key",
")",
";",
"root",
"node",
"=",
"leaf",
"delete",
"record",
"(",
"key",
",",
"is",
"indexed",
"?",
"this",
":",
"null",
")",
";",
"if",
"(",
"root",
"node",
"!",
"=",
"null",
")",
"{",
"int",
"id",
"=",
"root",
"node",
"get",
"buffer",
"id",
"(",
")",
";",
"if",
"(",
"root",
"buffer",
"id",
"!",
"=",
"id",
")",
"{",
"root",
"buffer",
"id",
"=",
"id",
";",
"table",
"record",
"set",
"root",
"buffer",
"id",
"(",
"root",
"buffer",
"id",
")",
";",
"}",
"}",
"else",
"{",
"root",
"buffer",
"id",
"=",
"-",
"1",
";",
"table",
"record",
"set",
"root",
"buffer",
"id",
"(",
"root",
"buffer",
"id",
")",
";",
"}",
"}",
"finally",
"{",
"/",
"/",
"release",
"node",
"buffers",
"and",
"update",
"record",
"count",
"int",
"delta",
"=",
"node",
"mgr",
"release",
"nodes",
"(",
")",
";",
"if",
"(",
"delta",
"!",
"=",
"0",
")",
"{",
"result",
"=",
"true",
";",
"record",
"count",
"+",
"=",
"delta",
";",
"table",
"record",
"set",
"record",
"count",
"(",
"record",
"count",
")",
";",
"}",
"}",
"return",
"result",
";",
"}",
"}"
] |
[
"get",
"exception",
"predicate"
] |
[
"public",
"static",
"predicate",
"<",
"?",
"extends",
"throwable",
">",
"get",
"exception",
"predicate",
"(",
")",
"{",
"return",
"exception",
"predicate",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"prefix",
"number",
"'"
] |
[
"public",
"void",
"prefix",
"number",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"prefix",
"number",
"}"
] |
[
"like",
"assert",
"equals",
",",
"but",
"fails",
"at",
"the",
"end",
"of",
"the",
"test",
"(",
"during",
"tear",
"down",
")"
] |
[
"public",
"void",
"verify",
"equals",
"(",
"string",
"[",
"]",
"s",
"1",
",",
"string",
"[",
"]",
"s",
"2",
")",
"{",
"stb",
"verify",
"equals",
"(",
"s",
"1",
",",
"s",
"2",
")",
";",
"}"
] |
[
"converts",
"the",
"provided",
"logging",
"event",
"to",
"a",
"generic",
"{",
"@",
"link",
"map",
"}"
] |
[
"protected",
"abstract",
"map",
"<",
"string",
",",
"object",
">",
"to",
"json",
"map",
"(",
"e",
"event",
")",
";"
] |
[
"test",
"that",
"we",
"receive",
"the",
"correct",
"number",
"of",
"transactions",
"when",
"we",
"count",
"the",
"number",
"of",
"transactions",
"around",
"gaps",
"set",
"up",
"a",
"single",
"edits",
"directory",
",",
"with",
"no",
"failures",
"delete",
"the",
"4th",
"logfile",
"test",
"that",
"get",
"number",
"of",
"transactions",
"returns",
"the",
"correct",
"number",
"of",
"transactions",
"before",
"this",
"gap",
"and",
"after",
"this",
"gap",
"also",
"verify",
"that",
"if",
"you",
"try",
"to",
"count",
"on",
"the",
"gap",
"that",
"an",
"exception",
"is",
"thrown"
] |
[
"public",
"void",
"test",
"many",
"logs",
"with",
"gaps",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"file",
"f",
"=",
"new",
"file",
"(",
"test",
"edit",
"log",
"test",
"dir",
"+",
"\"",
"/",
"manylogswithgaps",
"\"",
")",
";",
"n",
"n",
"storage",
"storage",
"=",
"setup",
"edits",
"(",
"collections",
"<",
"uri",
">",
"singleton",
"list",
"(",
"f",
"to",
"u",
"r",
"i",
"(",
")",
")",
",",
"10",
")",
";",
"storage",
"directory",
"sd",
"=",
"storage",
"dir",
"iterator",
"(",
"name",
"node",
"dir",
"type",
"edits",
")",
"next",
"(",
")",
";",
"final",
"long",
"start",
"gap",
"tx",
"id",
"=",
"3",
"*",
"txns",
"per",
"roll",
"+",
"1",
";",
"final",
"long",
"end",
"gap",
"tx",
"id",
"=",
"4",
"*",
"txns",
"per",
"roll",
";",
"file",
"[",
"]",
"files",
"=",
"new",
"file",
"(",
"f",
",",
"\"",
"current",
"\"",
")",
"list",
"files",
"(",
"new",
"filename",
"filter",
"(",
")",
"{",
"@",
"override",
"public",
"boolean",
"accept",
"(",
"file",
"dir",
",",
"string",
"name",
")",
"{",
"if",
"(",
"name",
"starts",
"with",
"(",
"n",
"n",
"storage",
"get",
"finalized",
"edits",
"file",
"name",
"(",
"start",
"gap",
"tx",
"id",
",",
"end",
"gap",
"tx",
"id",
")",
")",
")",
"{",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"}",
")",
";",
"assert",
"equals",
"(",
"1",
",",
"files",
"length",
")",
";",
"assert",
"true",
"(",
"files",
"[",
"0",
"]",
"delete",
"(",
")",
")",
";",
"file",
"journal",
"manager",
"jm",
"=",
"new",
"file",
"journal",
"manager",
"(",
"conf",
",",
"sd",
",",
"storage",
")",
";",
"assert",
"equals",
"(",
"start",
"gap",
"tx",
"id",
"-",
"1",
",",
"get",
"number",
"of",
"transactions",
"(",
"jm",
",",
"1",
",",
"true",
",",
"true",
")",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"get",
"number",
"of",
"transactions",
"(",
"jm",
",",
"start",
"gap",
"tx",
"id",
",",
"true",
",",
"true",
")",
")",
";",
"/",
"/",
"rolled",
"10",
"times",
"so",
"there",
"should",
"be",
"11",
"files",
"assert",
"equals",
"(",
"11",
"*",
"txns",
"per",
"roll",
"-",
"end",
"gap",
"tx",
"id",
",",
"get",
"number",
"of",
"transactions",
"(",
"jm",
",",
"end",
"gap",
"tx",
"id",
"+",
"1",
",",
"true",
",",
"true",
")",
")",
";",
"}"
] |
[
"searches",
"the",
"given",
"set",
"of",
"directory",
"paths",
"for",
"the",
"given",
"filename"
] |
[
"private",
"static",
"url",
"get",
"resource",
"(",
"list",
"<",
"string",
">",
"search",
"paths",
",",
"string",
"filename",
")",
"{",
"for",
"(",
"string",
"path",
":",
"search",
"paths",
")",
"{",
"file",
"f",
"=",
"new",
"file",
"(",
"path",
",",
"filename",
")",
";",
"if",
"(",
"!",
"f",
"exists",
"(",
")",
")",
"{",
"continue",
";",
"}",
"try",
"{",
"return",
"f",
"to",
"u",
"r",
"i",
"(",
")",
"to",
"u",
"r",
"l",
"(",
")",
";",
"}",
"catch",
"(",
"malformed",
"u",
"r",
"l",
"exception",
"e",
")",
"{",
"msg",
"debug",
"(",
"resource",
"manager",
"class",
",",
"\"",
"unable",
"to",
"create",
"url",
"for",
"file",
"\"",
",",
"e",
")",
";",
"}",
"}",
"return",
"null",
";",
"}"
] |
[
"resolves",
"a",
"name",
"to",
"a",
"global",
",",
"predeclared",
",",
"or",
"universal",
"binding"
] |
[
"scope",
"resolve",
"(",
"string",
"name",
")",
"throws",
"undefined",
";"
] |
[
"multiple",
"shared",
"edits",
"directories",
"is",
"an",
"invalid",
"configuration"
] |
[
"public",
"void",
"test",
"multiple",
"shared",
"dirs",
"fails",
"(",
")",
"throws",
"exception",
"{",
"configuration",
"conf",
"=",
"new",
"configuration",
"(",
")",
";",
"uri",
"shared",
"a",
"=",
"new",
"uri",
"(",
"\"",
"file",
":",
"/",
"/",
"/",
"shared",
"-",
"a",
"\"",
")",
";",
"uri",
"shared",
"b",
"=",
"new",
"uri",
"(",
"\"",
"file",
":",
"/",
"/",
"/",
"shared",
"-",
"b",
"\"",
")",
";",
"uri",
"local",
"a",
"=",
"new",
"uri",
"(",
"\"",
"file",
":",
"/",
"/",
"/",
"local",
"-",
"a",
"\"",
")",
";",
"conf",
"set",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"namenode",
"shared",
"edits",
"dir",
"key",
",",
"joiner",
"on",
"(",
"\"",
",",
"\"",
")",
"join",
"(",
"shared",
"a",
",",
"shared",
"b",
")",
")",
";",
"conf",
"set",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"namenode",
"edits",
"dir",
"key",
",",
"local",
"a",
"to",
"string",
"(",
")",
")",
";",
"try",
"{",
"f",
"s",
"namesystem",
"get",
"namespace",
"edits",
"dirs",
"(",
"conf",
")",
";",
"fail",
"(",
"\"",
"allowed",
"multiple",
"shared",
"edits",
"directories",
"\"",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ioe",
")",
"{",
"assert",
"equals",
"(",
"\"",
"multiple",
"shared",
"edits",
"directories",
"are",
"not",
"yet",
"supported",
"\"",
",",
"ioe",
"get",
"message",
"(",
")",
")",
";",
"}",
"}"
] |
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"this",
"range",
"set",
"contains",
"no",
"ranges"
] |
[
"boolean",
"is",
"empty",
"(",
")",
";"
] |
[
"call",
"this",
"when",
"you",
"are",
"done",
"with",
"this",
"inspector",
"and",
"will",
"not",
"use",
"it",
"again",
"cleans",
"up",
"listeners",
",",
"etc"
] |
[
"public",
"void",
"dispose",
"(",
")",
"{",
"if",
"(",
"options",
"object",
"!",
"=",
"null",
")",
"{",
"options",
"object",
"remove",
"options",
"change",
"listener",
"(",
"this",
")",
";",
"options",
"object",
"=",
"null",
";",
"}",
"repaint",
"comp",
"=",
"null",
";",
"set",
"program",
"(",
"null",
")",
";",
"}"
] |
[
"this",
"is",
"called",
"by",
"the",
"a",
"ms",
"started",
"on",
"this",
"node",
"to",
"register",
"with",
"the",
"rm",
"this",
"method",
"does",
"the",
"initial",
"authorization",
"and",
"then",
"forwards",
"the",
"request",
"to",
"the",
"application",
"instance",
"specific",
"intercepter",
"chain"
] |
[
"public",
"register",
"application",
"master",
"response",
"register",
"application",
"master",
"(",
"register",
"application",
"master",
"request",
"request",
")",
"throws",
"yarn",
"exception",
",",
"i",
"o",
"exception",
"{",
"long",
"start",
"time",
"=",
"clock",
"get",
"time",
"(",
")",
";",
"try",
"{",
"request",
"interceptor",
"chain",
"wrapper",
"pipeline",
"=",
"authorize",
"and",
"get",
"interceptor",
"chain",
"(",
")",
";",
"log",
"info",
"(",
"\"",
"registering",
"application",
"master",
"\"",
"+",
"\"",
"host",
":",
"\"",
"+",
"request",
"get",
"host",
"(",
")",
"+",
"\"",
"port",
":",
"\"",
"+",
"request",
"get",
"rpc",
"port",
"(",
")",
"+",
"\"",
"tracking",
"url",
":",
"\"",
"+",
"request",
"get",
"tracking",
"url",
"(",
")",
"+",
"\"",
"for",
"application",
"\"",
"+",
"pipeline",
"get",
"application",
"attempt",
"id",
"(",
")",
")",
";",
"register",
"application",
"master",
"response",
"response",
"=",
"pipeline",
"get",
"root",
"interceptor",
"(",
")",
"register",
"application",
"master",
"(",
"request",
")",
";",
"long",
"end",
"time",
"=",
"clock",
"get",
"time",
"(",
")",
";",
"this",
"metrics",
"succeeded",
"register",
"a",
"m",
"requests",
"(",
"end",
"time",
"-",
"start",
"time",
")",
";",
"log",
"info",
"(",
"\"",
"register",
"a",
"m",
"processing",
"finished",
"in",
"{",
"}",
"ms",
"for",
"application",
"{",
"}",
"\"",
",",
"end",
"time",
"-",
"start",
"time",
",",
"pipeline",
"get",
"application",
"attempt",
"id",
"(",
")",
")",
";",
"return",
"response",
";",
"}",
"catch",
"(",
"throwable",
"t",
")",
"{",
"this",
"metrics",
"incr",
"failed",
"register",
"a",
"m",
"requests",
"(",
")",
";",
"throw",
"t",
";",
"}",
"}"
] |
[
"sets",
"cache",
"remove",
"invocation",
"context",
",",
"see",
"{",
"@",
"link",
"cache",
"invocation",
"context",
"}",
"and",
"{",
"@",
"link",
"cache",
"remove",
"}"
] |
[
"public",
"builder",
"cache",
"remove",
"invocation",
"context",
"(",
"cache",
"invocation",
"context",
"<",
"cache",
"remove",
">",
"p",
"cache",
"remove",
"invocation",
"context",
")",
"{",
"this",
"cache",
"remove",
"invocation",
"context",
"=",
"p",
"cache",
"remove",
"invocation",
"context",
";",
"return",
"this",
";",
"}"
] |
[
"returns",
"one",
"active",
"replica",
"shard",
"for",
"the",
"given",
"shard",
"id",
"or",
"<",
"code",
">",
"null",
"<",
"code",
">",
"if",
"no",
"active",
"replica",
"is",
"found",
"since",
"replicas",
"could",
"possibly",
"be",
"on",
"nodes",
"with",
"a",
"older",
"version",
"of",
"es",
"than",
"the",
"primary",
"is",
",",
"this",
"will",
"return",
"replicas",
"on",
"the",
"highest",
"version",
"of",
"es"
] |
[
"public",
"shard",
"routing",
"active",
"replica",
"with",
"highest",
"version",
"(",
"shard",
"id",
"shard",
"id",
")",
"{",
"/",
"/",
"it",
"'",
"s",
"possible",
"for",
"replica",
"node",
"version",
"to",
"be",
"null",
",",
"when",
"disassociating",
"dead",
"nodes",
"/",
"/",
"that",
"have",
"been",
"removed",
",",
"the",
"shards",
"are",
"failed",
",",
"and",
"part",
"of",
"the",
"shard",
"failing",
"/",
"/",
"calls",
"this",
"method",
"with",
"an",
"out",
"-",
"of",
"-",
"date",
"routing",
"nodes",
",",
"where",
"the",
"version",
"might",
"not",
"/",
"/",
"be",
"accessible",
"therefore",
",",
"we",
"need",
"to",
"protect",
"against",
"the",
"version",
"being",
"null",
"/",
"/",
"(",
"meaning",
"the",
"node",
"will",
"be",
"going",
"away",
")",
"return",
"assigned",
"shards",
"(",
"shard",
"id",
")",
"stream",
"(",
")",
"filter",
"(",
"shr",
"-",
">",
"!",
"shr",
"primary",
"(",
")",
"&",
"&",
"shr",
"active",
"(",
")",
")",
"filter",
"(",
"shr",
"-",
">",
"node",
"(",
"shr",
"current",
"node",
"id",
"(",
")",
")",
"!",
"=",
"null",
")",
"max",
"(",
"comparator",
"comparing",
"(",
"shr",
"-",
">",
"node",
"(",
"shr",
"current",
"node",
"id",
"(",
")",
")",
"node",
"(",
")",
",",
"comparator",
"nulls",
"first",
"(",
"comparator",
"comparing",
"(",
"discovery",
"node",
":",
":",
"get",
"version",
")",
")",
")",
")",
"or",
"else",
"(",
"null",
")",
";",
"}"
] |
[
"reconfigure",
"-",
"addremove",
"servers",
"return",
"the",
"new",
"configuration"
] |
[
"public",
"byte",
"[",
"]",
"reconfigure",
"(",
"string",
"joining",
"servers",
",",
"string",
"leaving",
"servers",
",",
"string",
"new",
"members",
",",
"long",
"from",
"config",
",",
"stat",
"stat",
")",
"throws",
"keeper",
"exception",
",",
"interrupted",
"exception",
"{",
"request",
"header",
"h",
"=",
"new",
"request",
"header",
"(",
")",
";",
"h",
"set",
"type",
"(",
"zoo",
"defs",
"op",
"code",
"reconfig",
")",
";",
"reconfig",
"request",
"request",
"=",
"new",
"reconfig",
"request",
"(",
"joining",
"servers",
",",
"leaving",
"servers",
",",
"new",
"members",
",",
"from",
"config",
")",
";",
"get",
"data",
"response",
"response",
"=",
"new",
"get",
"data",
"response",
"(",
")",
";",
"reply",
"header",
"r",
"=",
"cnxn",
"submit",
"request",
"(",
"h",
",",
"request",
",",
"response",
",",
"null",
")",
";",
"if",
"(",
"r",
"get",
"err",
"(",
")",
"!",
"=",
"0",
")",
"{",
"throw",
"keeper",
"exception",
"create",
"(",
"keeper",
"exception",
"code",
"get",
"(",
"r",
"get",
"err",
"(",
")",
")",
",",
"\"",
"\"",
")",
";",
"}",
"if",
"(",
"stat",
"!",
"=",
"null",
")",
"{",
"data",
"tree",
"copy",
"stat",
"(",
"response",
"get",
"stat",
"(",
")",
",",
"stat",
")",
";",
"}",
"return",
"response",
"get",
"data",
"(",
")",
";",
"}"
] |
[
"build",
"the",
"permission",
"request"
] |
[
"public",
"permission",
"request",
"build",
"(",
")",
"{",
"if",
"(",
"m",
"rationale",
"=",
"=",
"null",
")",
"{",
"m",
"rationale",
"=",
"m",
"helper",
"get",
"context",
"(",
")",
"get",
"string",
"(",
"r",
"string",
"rationale",
"ask",
")",
";",
"}",
"if",
"(",
"m",
"positive",
"button",
"text",
"=",
"=",
"null",
")",
"{",
"m",
"positive",
"button",
"text",
"=",
"m",
"helper",
"get",
"context",
"(",
")",
"get",
"string",
"(",
"android",
"r",
"string",
"ok",
")",
";",
"}",
"if",
"(",
"m",
"negative",
"button",
"text",
"=",
"=",
"null",
")",
"{",
"m",
"negative",
"button",
"text",
"=",
"m",
"helper",
"get",
"context",
"(",
")",
"get",
"string",
"(",
"android",
"r",
"string",
"cancel",
")",
";",
"}",
"return",
"new",
"permission",
"request",
"(",
"m",
"helper",
",",
"m",
"perms",
",",
"m",
"request",
"code",
",",
"m",
"rationale",
",",
"m",
"positive",
"button",
"text",
",",
"m",
"negative",
"button",
"text",
",",
"m",
"theme",
")",
";",
"}"
] |
[
"tests",
"that",
"a",
"client",
"configured",
"using",
"grpc",
"ssl",
"contexts",
"refuses",
"to",
"talk",
"to",
"a",
"server",
"that",
"has",
"an",
"an",
"untrusted",
"certificate"
] |
[
"public",
"void",
"client",
"rejects",
"untrusted",
"server",
"cert",
"(",
")",
"throws",
"exception",
"{",
"try",
"{",
"remoting",
"command",
"response",
"=",
"remoting",
"client",
"invoke",
"sync",
"(",
"\"",
"localhost",
":",
"8888",
"\"",
",",
"create",
"request",
"(",
")",
",",
"1000",
"*",
"3",
")",
";",
"fail",
"because",
"exception",
"was",
"not",
"thrown",
"(",
"remoting",
"send",
"request",
"exception",
"class",
")",
";",
"}",
"catch",
"(",
"remoting",
"send",
"request",
"exception",
"ignore",
")",
"{",
"}",
"}"
] |
[
"removes",
"the",
"set",
"of",
"functions",
"from",
"the",
"comparison",
"model"
] |
[
"public",
"void",
"remove",
"functions",
"(",
"set",
"<",
"function",
">",
"functions",
")",
"{",
"functions",
"stream",
"(",
")",
"for",
"each",
"(",
"f",
"-",
">",
"model",
"remove",
"function",
"(",
"f",
")",
")",
";",
"close",
"if",
"empty",
"(",
")",
";",
"}"
] |
[
"get",
"direct",
"map"
] |
[
"public",
"map",
"<",
"string",
",",
"boolean",
">",
"get",
"direct",
"map",
"(",
")",
"{",
"return",
"direct",
"map",
";",
"}"
] |
[
"returns",
"a",
"signed",
"value",
"indicating",
"how",
"many",
"nested",
"invocations",
"of",
"{",
"@",
"link",
"#",
"next",
"}",
"(",
"if",
"positive",
")",
"or",
"{",
"@",
"link",
"#",
"previous",
"}",
"(",
"if",
"negative",
")",
"are",
"needed",
"to",
"reach",
"{",
"@",
"code",
"end",
"}",
"starting",
"from",
"{",
"@",
"code",
"start",
"}",
"for",
"example",
",",
"if",
"{",
"@",
"code",
"end",
"=",
"next",
"(",
"next",
"(",
"next",
"(",
"start",
")",
")",
")",
"}",
",",
"then",
"{",
"@",
"code",
"distance",
"(",
"start",
",",
"end",
")",
"=",
"=",
"3",
"}",
"and",
"{",
"@",
"code",
"distance",
"(",
"end",
",",
"start",
")",
"=",
"=",
"-",
"3",
"}",
"as",
"well",
",",
"{",
"@",
"code",
"distance",
"(",
"a",
",",
"a",
")",
"}",
"is",
"always",
"zero",
"note",
"that",
"this",
"function",
"is",
"necessarily",
"well",
"-",
"defined",
"for",
"any",
"discrete",
"type"
] |
[
"public",
"abstract",
"long",
"distance",
"(",
"c",
"start",
",",
"c",
"end",
")",
";"
] |
[
"pops",
"the",
"top",
"float",
"value",
"from",
"the",
"stack"
] |
[
"public",
"float",
"value",
"fpop",
"(",
")",
"{",
"return",
"pop",
"(",
")",
"float",
"value",
"(",
")",
";",
"}"
] |
[
"run",
"the",
"map",
"task"
] |
[
"public",
"void",
"run",
"(",
"record",
"reader",
"<",
"k1",
",",
"v1",
">",
"input",
",",
"output",
"collector",
"<",
"k2",
",",
"v2",
">",
"output",
",",
"reporter",
"reporter",
")",
"throws",
"i",
"o",
"exception",
"{",
"application",
"<",
"k1",
",",
"v1",
",",
"k2",
",",
"v2",
">",
"application",
"=",
"null",
";",
"try",
"{",
"record",
"reader",
"<",
"float",
"writable",
",",
"null",
"writable",
">",
"fake",
"input",
"=",
"(",
"!",
"submitter",
"get",
"is",
"java",
"record",
"reader",
"(",
"job",
")",
"&",
"&",
"!",
"submitter",
"get",
"is",
"java",
"mapper",
"(",
"job",
")",
")",
"?",
"(",
"record",
"reader",
"<",
"float",
"writable",
",",
"null",
"writable",
">",
")",
"input",
":",
"null",
";",
"application",
"=",
"new",
"application",
"<",
"k1",
",",
"v1",
",",
"k2",
",",
"v2",
">",
"(",
"job",
",",
"fake",
"input",
",",
"output",
",",
"reporter",
",",
"(",
"class",
"<",
"?",
"extends",
"k2",
">",
")",
"job",
"get",
"output",
"key",
"class",
"(",
")",
",",
"(",
"class",
"<",
"?",
"extends",
"v2",
">",
")",
"job",
"get",
"output",
"value",
"class",
"(",
")",
")",
";",
"}",
"catch",
"(",
"interrupted",
"exception",
"ie",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"interrupted",
"\"",
",",
"ie",
")",
";",
"}",
"downward",
"protocol",
"<",
"k1",
",",
"v1",
">",
"downlink",
"=",
"application",
"get",
"downlink",
"(",
")",
";",
"boolean",
"is",
"java",
"input",
"=",
"submitter",
"get",
"is",
"java",
"record",
"reader",
"(",
"job",
")",
";",
"downlink",
"run",
"map",
"(",
"reporter",
"get",
"input",
"split",
"(",
")",
",",
"job",
"get",
"num",
"reduce",
"tasks",
"(",
")",
",",
"is",
"java",
"input",
")",
";",
"boolean",
"skipping",
"=",
"job",
"get",
"boolean",
"(",
"m",
"r",
"job",
"config",
"skip",
"records",
",",
"false",
")",
";",
"try",
"{",
"if",
"(",
"is",
"java",
"input",
")",
"{",
"/",
"/",
"allocate",
"key",
"&",
"value",
"instances",
"that",
"are",
"re",
"-",
"used",
"for",
"all",
"entries",
"k1",
"key",
"=",
"input",
"create",
"key",
"(",
")",
";",
"v1",
"value",
"=",
"input",
"create",
"value",
"(",
")",
";",
"downlink",
"set",
"input",
"types",
"(",
"key",
"get",
"class",
"(",
")",
"get",
"name",
"(",
")",
",",
"value",
"get",
"class",
"(",
")",
"get",
"name",
"(",
")",
")",
";",
"while",
"(",
"input",
"next",
"(",
"key",
",",
"value",
")",
")",
"{",
"/",
"/",
"map",
"pair",
"to",
"output",
"downlink",
"map",
"item",
"(",
"key",
",",
"value",
")",
";",
"if",
"(",
"skipping",
")",
"{",
"/",
"/",
"flush",
"the",
"streams",
"on",
"every",
"record",
"input",
"if",
"running",
"in",
"skip",
"mode",
"/",
"/",
"so",
"that",
"we",
"don",
"'",
"t",
"buffer",
"other",
"records",
"surrounding",
"a",
"bad",
"record",
"downlink",
"flush",
"(",
")",
";",
"}",
"}",
"downlink",
"end",
"of",
"input",
"(",
")",
";",
"}",
"application",
"wait",
"for",
"finish",
"(",
")",
";",
"}",
"catch",
"(",
"throwable",
"t",
")",
"{",
"application",
"abort",
"(",
"t",
")",
";",
"}",
"finally",
"{",
"application",
"cleanup",
"(",
")",
";",
"}",
"}"
] |
[
"returns",
"a",
"{",
"@",
"link",
"converter",
"}",
"for",
"{",
"@",
"link",
"response",
"body",
"}",
"to",
"{",
"@",
"code",
"type",
"}",
"from",
"the",
"available",
"{",
"@",
"linkplain",
"#",
"converter",
"factories",
"(",
")",
"factories",
"}"
] |
[
"public",
"<",
"t",
">",
"converter",
"<",
"response",
"body",
",",
"t",
">",
"response",
"body",
"converter",
"(",
"type",
"type",
",",
"annotation",
"[",
"]",
"annotations",
")",
"{",
"return",
"next",
"response",
"body",
"converter",
"(",
"null",
",",
"type",
",",
"annotations",
")",
";",
"}"
] |
[
"logs",
"user",
"into",
"the",
"system"
] |
[
"string",
"login",
"user",
"(",
"@",
"param",
"(",
"\"",
"username",
"\"",
")",
"string",
"username",
",",
"@",
"param",
"(",
"\"",
"password",
"\"",
")",
"string",
"password",
")",
";"
] |
[
"get",
"an",
"environment",
"variable"
] |
[
"public",
"string",
"get",
"environment",
"(",
"string",
"env",
")",
"{",
"return",
"environment",
"get",
"(",
"env",
")",
";",
"}"
] |
[
"return",
"the",
"actually",
"supported",
"http",
"methods",
"as",
"{",
"@",
"link",
"http",
"method",
"}",
"instances",
",",
"or",
"{",
"@",
"code",
"null",
"}",
"if",
"not",
"known"
] |
[
"public",
"set",
"<",
"http",
"method",
">",
"get",
"supported",
"http",
"methods",
"(",
")",
"{",
"if",
"(",
"this",
"supported",
"methods",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"list",
"<",
"http",
"method",
">",
"supported",
"methods",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"this",
"supported",
"methods",
"length",
")",
";",
"for",
"(",
"string",
"value",
":",
"this",
"supported",
"methods",
")",
"{",
"http",
"method",
"resolved",
"=",
"http",
"method",
"resolve",
"(",
"value",
")",
";",
"if",
"(",
"resolved",
"!",
"=",
"null",
")",
"{",
"supported",
"methods",
"add",
"(",
"resolved",
")",
";",
"}",
"}",
"return",
"enum",
"set",
"copy",
"of",
"(",
"supported",
"methods",
")",
";",
"}"
] |
[
"creates",
"a",
"new",
"{",
"@",
"link",
"processing",
"timeout",
"trigger",
"}",
"that",
"fires",
"when",
"the",
"inner",
"trigger",
"is",
"fired",
"or",
"when",
"the",
"timeout",
"timer",
"fires",
"for",
"example",
":",
"{",
"@",
"code",
"processing",
"timeout",
"trigger",
"of",
"(",
"count",
"trigger",
"of",
"(",
"3",
")",
",",
"100",
")",
"}",
",",
"will",
"create",
"a",
"count",
"trigger",
"with",
"timeout",
"of",
"100",
"millis",
"so",
",",
"if",
"the",
"first",
"record",
"arrives",
"at",
"time",
"{",
"@",
"code",
"t",
"}",
",",
"and",
"the",
"second",
"record",
"arrives",
"at",
"time",
"{",
"@",
"code",
"t",
"+",
"50",
"}",
",",
"the",
"trigger",
"will",
"fire",
"when",
"the",
"third",
"record",
"arrives",
"or",
"when",
"the",
"time",
"is",
"{",
"code",
"t",
"+",
"100",
"}",
"(",
"timeout",
")"
] |
[
"public",
"static",
"<",
"t",
",",
"w",
"extends",
"window",
">",
"processing",
"timeout",
"trigger",
"<",
"t",
",",
"w",
">",
"of",
"(",
"trigger",
"<",
"t",
",",
"w",
">",
"nested",
"trigger",
",",
"duration",
"timeout",
")",
"{",
"return",
"new",
"processing",
"timeout",
"trigger",
"<",
">",
"(",
"nested",
"trigger",
",",
"timeout",
"to",
"millis",
"(",
")",
",",
"false",
",",
"true",
")",
";",
"}"
] |
[
"adds",
"the",
"given",
"icon",
"as",
"an",
"overlay",
"to",
"the",
"base",
"icon",
",",
"to",
"the",
"lower",
"-",
"right"
] |
[
"public",
"multi",
"icon",
"builder",
"add",
"lower",
"right",
"icon",
"(",
"icon",
"icon",
")",
"{",
"return",
"add",
"icon",
"(",
"icon",
",",
"icon",
"get",
"icon",
"width",
"(",
")",
",",
"icon",
"get",
"icon",
"height",
"(",
")",
",",
"quadrant",
"lr",
")",
";",
"}"
] |
[
"create",
"a",
"new",
"{",
"@",
"code",
"server",
"request",
"}",
"based",
"on",
"the",
"given",
"{",
"@",
"code",
"http",
"servlet",
"request",
"}",
"and",
"message",
"converters"
] |
[
"static",
"server",
"request",
"create",
"(",
"http",
"servlet",
"request",
"servlet",
"request",
",",
"list",
"<",
"http",
"message",
"converter",
"<",
"?",
">",
">",
"message",
"readers",
")",
"{",
"return",
"new",
"default",
"server",
"request",
"(",
"servlet",
"request",
",",
"message",
"readers",
")",
";",
"}"
] |
[
"appends",
"the",
"maximum",
"java",
"heap",
"size",
"(",
"-",
"xmx",
")",
"to",
"the",
"vm",
"arguments",
"in",
"the",
"provided",
"working",
"copy"
] |
[
"public",
"static",
"i",
"launch",
"configuration",
"working",
"copy",
"set",
"memory",
"(",
"i",
"launch",
"configuration",
"working",
"copy",
"wc",
",",
"string",
"memory",
")",
"throws",
"core",
"exception",
"{",
"if",
"(",
"memory",
"!",
"=",
"null",
")",
"{",
"string",
"vm",
"args",
"=",
"wc",
"get",
"attribute",
"(",
"attr",
"vm",
"arguments",
",",
"\"",
"\"",
")",
";",
"if",
"(",
"!",
"vm",
"args",
"is",
"empty",
"(",
")",
")",
"{",
"vm",
"args",
"+",
"=",
"\"",
"\"",
";",
"}",
"wc",
"set",
"attribute",
"(",
"attr",
"vm",
"arguments",
",",
"vm",
"args",
"+",
"\"",
"-",
"xmx",
"\"",
"+",
"memory",
")",
";",
"}",
"return",
"wc",
";",
"}"
] |
[
"triggers",
"an",
"{",
"@",
"link",
"channel",
"inbound",
"handler",
"#",
"channel",
"read",
"complete",
"(",
"channel",
"handler",
"context",
")",
"}",
"event",
"to",
"the",
"next",
"{",
"@",
"link",
"channel",
"inbound",
"handler",
"}",
"in",
"the",
"{",
"@",
"link",
"channel",
"pipeline",
"}"
] |
[
"channel",
"inbound",
"invoker",
"fire",
"channel",
"read",
"complete",
"(",
")",
";"
] |
[
"gets",
"the",
"{",
"@",
"link",
"mocom",
"}",
"kind"
] |
[
"public",
"mocom",
"get",
"mocom",
"(",
")",
"{",
"return",
"mocom",
";",
"}"
] |
[
"groups",
"by",
"vertex",
"and",
"computes",
"a",
"group",
"reduce",
"transformation",
"over",
"the",
"edge",
"values",
"of",
"each",
"vertex",
"the",
"edges",
"function",
"applied",
"on",
"the",
"edges",
"has",
"access",
"to",
"both",
"the",
"id",
"and",
"the",
"value",
"of",
"the",
"grouping",
"vertex",
"for",
"each",
"vertex",
",",
"the",
"edges",
"function",
"can",
"iterate",
"over",
"all",
"edges",
"of",
"this",
"vertex",
"with",
"the",
"specified",
"direction",
",",
"and",
"emit",
"any",
"number",
"of",
"output",
"elements",
",",
"including",
"none"
] |
[
"public",
"<",
"t",
">",
"data",
"set",
"<",
"t",
">",
"group",
"reduce",
"on",
"edges",
"(",
"edges",
"function",
"with",
"vertex",
"value",
"<",
"k",
",",
"vv",
",",
"ev",
",",
"t",
">",
"edges",
"function",
",",
"edge",
"direction",
"direction",
",",
"type",
"information",
"<",
"t",
">",
"type",
"info",
")",
"throws",
"illegal",
"argument",
"exception",
"{",
"switch",
"(",
"direction",
")",
"{",
"case",
"in",
":",
"return",
"vertices",
"co",
"group",
"(",
"edges",
")",
"where",
"(",
"0",
")",
"equal",
"to",
"(",
"1",
")",
"with",
"(",
"new",
"apply",
"co",
"group",
"function",
"<",
">",
"(",
"edges",
"function",
")",
")",
"name",
"(",
"\"",
"group",
"reduce",
"on",
"in",
"-",
"edges",
"\"",
")",
"returns",
"(",
"type",
"info",
")",
";",
"case",
"out",
":",
"return",
"vertices",
"co",
"group",
"(",
"edges",
")",
"where",
"(",
"0",
")",
"equal",
"to",
"(",
"0",
")",
"with",
"(",
"new",
"apply",
"co",
"group",
"function",
"<",
">",
"(",
"edges",
"function",
")",
")",
"name",
"(",
"\"",
"group",
"reduce",
"on",
"out",
"-",
"edges",
"\"",
")",
"returns",
"(",
"type",
"info",
")",
";",
"case",
"all",
":",
"return",
"vertices",
"co",
"group",
"(",
"edges",
"flat",
"map",
"(",
"new",
"emit",
"one",
"edge",
"per",
"node",
"<",
">",
"(",
")",
")",
"name",
"(",
"\"",
"emit",
"edge",
"\"",
")",
")",
"where",
"(",
"0",
")",
"equal",
"to",
"(",
"0",
")",
"with",
"(",
"new",
"apply",
"co",
"group",
"function",
"on",
"all",
"edges",
"<",
">",
"(",
"edges",
"function",
")",
")",
"name",
"(",
"\"",
"group",
"reduce",
"on",
"in",
"-",
"and",
"out",
"-",
"edges",
"\"",
")",
"returns",
"(",
"type",
"info",
")",
";",
"default",
":",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"illegal",
"edge",
"direction",
"\"",
")",
";",
"}",
"}"
] |
[
"add",
"a",
"new",
"pet",
"to",
"the",
"store"
] |
[
"public",
"void",
"add",
"pet",
"(",
"pet",
"body",
")",
"{",
"/",
"/",
"todo",
":",
"implement",
"}"
] |
[
"this",
"method",
"is",
"the",
"same",
"as",
"{",
"@",
"link",
"#",
"create",
"data",
"(",
"data",
"type",
",",
"program",
"location",
")",
"}",
",",
"except",
"that",
"this",
"method",
"will",
"use",
"the",
"given",
"value",
"of",
"<",
"tt",
">",
"convert",
"pointers",
"<",
"tt",
">",
"to",
"determine",
"if",
"the",
"new",
"data",
"type",
"should",
"be",
"made",
"into",
"a",
"pointer",
"if",
"the",
"existing",
"data",
"type",
"is",
"a",
"pointer"
] |
[
"public",
"boolean",
"create",
"data",
"(",
"data",
"type",
"data",
"type",
",",
"listing",
"action",
"context",
"context",
",",
"boolean",
"convert",
"pointers",
",",
"boolean",
"prompt",
"for",
"conflict",
"removal",
")",
"{",
"program",
"location",
"location",
"=",
"context",
"get",
"location",
"(",
")",
";",
"program",
"program",
"=",
"context",
"get",
"program",
"(",
")",
";",
"if",
"(",
"!",
"(",
"location",
"instanceof",
"function",
"location",
")",
")",
"{",
"tool",
"set",
"status",
"info",
"(",
"\"",
"unsupported",
"function",
"location",
"for",
"data",
"-",
"type",
"\"",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"data",
"type",
"!",
"=",
"data",
"type",
"default",
"&",
"&",
"data",
"type",
"!",
"=",
"data",
"type",
"void",
")",
"{",
"dtm",
"service",
"set",
"recently",
"used",
"(",
"data",
"type",
")",
";",
"}",
"function",
"function",
"=",
"get",
"function",
"(",
"context",
")",
";",
"if",
"(",
"function",
"=",
"=",
"null",
")",
"{",
"tool",
"set",
"status",
"info",
"(",
"\"",
"unsupported",
"function",
"location",
"for",
"data",
"-",
"type",
"\"",
")",
";",
"return",
"false",
";",
"}",
"/",
"/",
"todo",
":",
"this",
"will",
"not",
"allow",
"setting",
"a",
"return",
"value",
"as",
"a",
"function",
"pointer",
"if",
"(",
"(",
"location",
"instanceof",
"function",
"signature",
"field",
"location",
")",
"&",
"&",
"(",
"data",
"type",
"instanceof",
"function",
"signature",
")",
")",
"{",
"return",
"tool",
"execute",
"(",
"new",
"apply",
"function",
"signature",
"cmd",
"(",
"function",
"get",
"entry",
"point",
"(",
")",
",",
"(",
"function",
"signature",
")",
"data",
"type",
",",
"source",
"type",
"user",
"defined",
")",
",",
"program",
")",
";",
"}",
"data",
"type",
"existing",
"d",
"t",
"=",
"get",
"current",
"data",
"type",
"(",
"context",
")",
";",
"data",
"type",
"=",
"data",
"utilities",
"reconcile",
"applied",
"data",
"type",
"(",
"existing",
"d",
"t",
",",
"data",
"type",
",",
"convert",
"pointers",
")",
";",
"if",
"(",
"data",
"type",
"get",
"length",
"(",
")",
"<",
"0",
")",
"{",
"tool",
"set",
"status",
"info",
"(",
"\"",
"only",
"fixed",
"-",
"length",
"data",
"-",
"type",
"permitted",
"\"",
")",
";",
"return",
"false",
";",
"}",
"/",
"/",
"this",
"check",
"must",
"come",
"before",
"the",
"signature",
"check",
",",
"since",
"this",
"is",
"a",
"function",
"signature",
"field",
"location",
"if",
"(",
"location",
"instanceof",
"function",
"parameter",
"field",
"location",
")",
"{",
"function",
"parameter",
"field",
"location",
"parameter",
"location",
"=",
"(",
"function",
"parameter",
"field",
"location",
")",
"location",
";",
"parameter",
"parameter",
"=",
"parameter",
"location",
"get",
"parameter",
"(",
")",
";",
"return",
"set",
"variable",
"data",
"type",
"(",
"parameter",
",",
"data",
"type",
",",
"prompt",
"for",
"conflict",
"removal",
")",
";",
"}",
"else",
"if",
"(",
"location",
"instanceof",
"function",
"signature",
"field",
"location",
")",
"{",
"source",
"type",
"source",
"=",
"(",
"data",
"type",
"=",
"=",
"data",
"type",
"default",
")",
"?",
"source",
"type",
"default",
":",
"source",
"type",
"user",
"defined",
";",
"return",
"tool",
"execute",
"(",
"new",
"set",
"return",
"data",
"type",
"cmd",
"(",
"function",
"get",
"entry",
"point",
"(",
")",
",",
"data",
"type",
",",
"source",
")",
",",
"program",
")",
";",
"}",
"else",
"if",
"(",
"location",
"instanceof",
"variable",
"location",
")",
"{",
"variable",
"variable",
"=",
"(",
"(",
"variable",
"location",
")",
"location",
")",
"get",
"variable",
"(",
")",
";",
"return",
"set",
"variable",
"data",
"type",
"(",
"variable",
",",
"data",
"type",
",",
"prompt",
"for",
"conflict",
"removal",
")",
";",
"}",
"tool",
"set",
"status",
"info",
"(",
"\"",
"unsupported",
"function",
"location",
"for",
"data",
"-",
"type",
"\"",
")",
";",
"return",
"false",
";",
"}"
] |
[
"this",
"method",
"handles",
"writing",
"out",
"the",
"certificate",
"authority",
"cert",
"and",
"private",
"key",
"if",
"the",
"certificate",
"authority",
"was",
"generated",
"by",
"this",
"invocation",
"of",
"the",
"tool"
] |
[
"private",
"static",
"void",
"write",
"c",
"a",
"info",
"if",
"generated",
"(",
"zip",
"output",
"stream",
"output",
"stream",
",",
"jca",
"p",
"e",
"m",
"writer",
"pem",
"writer",
",",
"c",
"a",
"info",
"info",
")",
"throws",
"exception",
"{",
"if",
"(",
"info",
"generated",
")",
"{",
"final",
"string",
"ca",
"dir",
"name",
"=",
"\"",
"ca",
"/",
"\"",
";",
"zip",
"entry",
"zip",
"entry",
"=",
"new",
"zip",
"entry",
"(",
"ca",
"dir",
"name",
")",
";",
"assert",
"zip",
"entry",
"is",
"directory",
"(",
")",
";",
"output",
"stream",
"put",
"next",
"entry",
"(",
"zip",
"entry",
")",
";",
"output",
"stream",
"put",
"next",
"entry",
"(",
"new",
"zip",
"entry",
"(",
"ca",
"dir",
"name",
"+",
"\"",
"ca",
"crt",
"\"",
")",
")",
";",
"pem",
"writer",
"write",
"object",
"(",
"info",
"ca",
"cert",
")",
";",
"pem",
"writer",
"flush",
"(",
")",
";",
"output",
"stream",
"close",
"entry",
"(",
")",
";",
"output",
"stream",
"put",
"next",
"entry",
"(",
"new",
"zip",
"entry",
"(",
"ca",
"dir",
"name",
"+",
"\"",
"ca",
"key",
"\"",
")",
")",
";",
"if",
"(",
"info",
"password",
"!",
"=",
"null",
"&",
"&",
"info",
"password",
"length",
">",
"0",
")",
"{",
"try",
"{",
"p",
"e",
"m",
"encryptor",
"encryptor",
"=",
"new",
"jce",
"p",
"e",
"m",
"encryptor",
"builder",
"(",
"\"",
"des",
"-",
"ede3",
"-",
"cbc",
"\"",
")",
"set",
"provider",
"(",
"bc",
"prov",
")",
"build",
"(",
"info",
"password",
")",
";",
"pem",
"writer",
"write",
"object",
"(",
"info",
"private",
"key",
",",
"encryptor",
")",
";",
"}",
"finally",
"{",
"/",
"/",
"we",
"can",
"safely",
"nuke",
"the",
"password",
"chars",
"now",
"arrays",
"fill",
"(",
"info",
"password",
",",
"(",
"char",
")",
"0",
")",
";",
"}",
"}",
"else",
"{",
"pem",
"writer",
"write",
"object",
"(",
"info",
"private",
"key",
")",
";",
"}",
"pem",
"writer",
"flush",
"(",
")",
";",
"output",
"stream",
"close",
"entry",
"(",
")",
";",
"}",
"}"
] |
[
"we",
"might",
"need",
"to",
"do",
"some",
"setup",
"when",
"the",
"litho",
"view",
"is",
"available",
"ex",
":",
"for",
"focused",
"events",
"we",
"need",
"to",
"know",
"the",
"size",
"of",
"the",
"parent",
"litho",
"view",
"to",
"decide",
"how",
"much",
"the",
"item",
"needs",
"to",
"be",
"visible",
"to",
"be",
"eligible"
] |
[
"void",
"on",
"litho",
"view",
"available",
"(",
"view",
"view",
")",
";"
] |
[
"post",
"fakeinline",
"-",
"additional",
"properties",
":",
"test",
"inline",
"additional",
"properties"
] |
[
"default",
"completable",
"future",
"<",
"response",
"entity",
"<",
"void",
">",
">",
"test",
"inline",
"additional",
"properties",
"(",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"request",
"body",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"body",
"map",
"<",
"string",
",",
"string",
">",
"param",
")",
"{",
"return",
"completable",
"future",
"completed",
"future",
"(",
"new",
"response",
"entity",
"<",
">",
"(",
"http",
"status",
"not",
"implemented",
")",
")",
";",
"}"
] |
[
"convert",
"a",
"supplied",
"set",
"of",
"arguments",
"into",
"the",
"requested",
"types",
"if",
"the",
"parameter",
"types",
"are",
"related",
"to",
"a",
"varargs",
"method",
"then",
"the",
"final",
"entry",
"in",
"the",
"parameter",
"types",
"array",
"is",
"going",
"to",
"be",
"an",
"array",
"itself",
"whose",
"component",
"type",
"should",
"be",
"used",
"as",
"the",
"conversion",
"target",
"for",
"extraneous",
"arguments",
"(",
"for",
"example",
",",
"if",
"the",
"parameter",
"types",
"are",
"{",
"integer",
",",
"string",
"[",
"]",
"}",
"and",
"the",
"input",
"arguments",
"are",
"{",
"integer",
",",
"boolean",
",",
"float",
"}",
"then",
"both",
"the",
"boolean",
"and",
"float",
"must",
"be",
"converted",
"to",
"strings",
")",
"this",
"method",
"does",
"not",
"repackage",
"the",
"arguments",
"into",
"a",
"form",
"suitable",
"for",
"the",
"varargs",
"invocation",
"-",
"a",
"subsequent",
"call",
"to",
"setup",
"arguments",
"for",
"varargs",
"invocation",
"handles",
"that"
] |
[
"public",
"static",
"boolean",
"convert",
"all",
"arguments",
"(",
"type",
"converter",
"converter",
",",
"object",
"[",
"]",
"arguments",
",",
"method",
"method",
")",
"throws",
"spel",
"evaluation",
"exception",
"{",
"integer",
"varargs",
"position",
"=",
"(",
"method",
"is",
"var",
"args",
"(",
")",
"?",
"method",
"get",
"parameter",
"count",
"(",
")",
"-",
"1",
":",
"null",
")",
";",
"return",
"convert",
"arguments",
"(",
"converter",
",",
"arguments",
",",
"method",
",",
"varargs",
"position",
")",
";",
"}"
] |
[
"enable",
"url",
"path",
"matching",
"with",
"parsed",
"{",
"@",
"link",
"org",
"springframework",
"web",
"util",
"pattern",
"path",
"pattern",
"path",
"patterns",
"}",
"this",
"is",
"delegated",
"to",
"{",
"@",
"link",
"standalone",
"mock",
"mvc",
"builder",
"#",
"set",
"pattern",
"parser",
"(",
"path",
"pattern",
"parser",
")",
"}"
] |
[
"controller",
"spec",
"pattern",
"parser",
"(",
"path",
"pattern",
"parser",
"parser",
")",
";"
] |
[
"log",
"a",
"message",
"with",
"fatal",
"log",
"level"
] |
[
"public",
"void",
"fatal",
"(",
"supplier",
"<",
"?",
"extends",
"char",
"sequence",
">",
"message",
"supplier",
")",
"{",
"if",
"(",
"this",
"log",
"is",
"fatal",
"enabled",
"(",
")",
")",
"{",
"this",
"log",
"fatal",
"(",
"log",
"message",
"of",
"(",
"message",
"supplier",
")",
")",
";",
"}",
"}"
] |
[
"s",
"how",
"similar",
"the",
"suggested",
"terms",
"at",
"least",
"need",
"to",
"be",
"compared",
"to",
"the",
"original",
"suggest",
"text",
"tokens",
"a",
"value",
"between",
"0",
"and",
"1",
"can",
"be",
"specified",
"this",
"value",
"will",
"be",
"compared",
"to",
"the",
"string",
"distance",
"result",
"of",
"each",
"candidate",
"spelling",
"correction",
"default",
"is",
"{",
"@",
"code",
"0",
"5",
"}"
] |
[
"public",
"term",
"suggestion",
"builder",
"accuracy",
"(",
"float",
"accuracy",
")",
"{",
"if",
"(",
"accuracy",
"<",
"0",
"0f",
"|",
"|",
"accuracy",
">",
"1",
"0f",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"accuracy",
"must",
"be",
"between",
"0",
"and",
"1",
"\"",
")",
";",
"}",
"this",
"accuracy",
"=",
"accuracy",
";",
"return",
"this",
";",
"}"
] |
[
"return",
"a",
"new",
"{",
"@",
"code",
"data",
"buffer",
"}",
"composed",
"of",
"the",
"{",
"@",
"code",
"data",
"buffers",
"}",
"elements",
"joined",
"together",
"depending",
"on",
"the",
"implementation",
",",
"the",
"returned",
"buffer",
"may",
"be",
"a",
"single",
"buffer",
"containing",
"all",
"data",
"of",
"the",
"provided",
"buffers",
",",
"or",
"it",
"may",
"be",
"a",
"true",
"composite",
"that",
"contains",
"references",
"to",
"the",
"buffers",
"note",
"that",
"the",
"given",
"data",
"buffers",
"do",
"not",
"have",
"to",
"be",
"released",
",",
"as",
"they",
"are",
"released",
"as",
"part",
"of",
"the",
"returned",
"composite"
] |
[
"data",
"buffer",
"join",
"(",
"list",
"<",
"?",
"extends",
"data",
"buffer",
">",
"data",
"buffers",
")",
";"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"public",
"void",
"align",
"to",
"(",
"int",
"alignment",
")",
"{",
"int",
"mask",
"=",
"alignment",
"-",
"1",
";",
"if",
"(",
"(",
"alignment",
"<",
"0",
")",
"|",
"|",
"(",
"(",
"mask",
"&",
"alignment",
")",
"!",
"=",
"0",
")",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"bogus",
"alignment",
"\"",
")",
";",
"}",
"int",
"end",
"=",
"(",
"cursor",
"+",
"mask",
")",
"&",
"~",
"mask",
";",
"if",
"(",
"stretchy",
")",
"{",
"ensure",
"capacity",
"(",
"end",
")",
";",
"}",
"else",
"if",
"(",
"end",
">",
"data",
"length",
")",
"{",
"throw",
"bounds",
"(",
")",
";",
"return",
";",
"}",
"/",
"*",
"*",
"there",
"is",
"no",
"need",
"to",
"actually",
"write",
"zeroes",
",",
"since",
"the",
"array",
"is",
"*",
"already",
"preinitialized",
"with",
"zeroes",
"*",
"/",
"cursor",
"=",
"end",
";",
"}"
] |
[
"consume",
"the",
"most",
"recently",
"received",
"but",
"not",
"yet",
"a",
"c",
"ked",
"settings"
] |
[
"void",
"consume",
"received",
"settings",
"(",
"http",
"2",
"settings",
"settings",
")",
";"
] |
[
"add",
"the",
"supplied",
"attribute",
"to",
"the",
"model",
"using",
"a",
"{",
"@",
"linkplain",
"org",
"springframework",
"core",
"conventions",
"#",
"get",
"variable",
"name",
"generated",
"name",
"}",
"note",
":",
"empty",
"{",
"@",
"link",
"collection",
"collections",
"}",
"are",
"not",
"added",
"to",
"the",
"model",
"when",
"using",
"this",
"method",
"because",
"we",
"cannot",
"correctly",
"determine",
"the",
"true",
"convention",
"name",
"view",
"code",
"should",
"check",
"for",
"{",
"@",
"code",
"null",
"}",
"rather",
"than",
"for",
"empty",
"collections"
] |
[
"builder",
"model",
"attribute",
"(",
"object",
"attribute",
")",
";"
] |
[
"return",
"the",
"size",
"of",
"the",
"remaining",
"available",
"bytes",
"if",
"the",
"size",
"is",
"less",
"than",
"or",
"equal",
"to",
"{",
"@",
"link",
"integer",
"#",
"max",
"value",
"}",
",",
"otherwise",
",",
"return",
"{",
"@",
"link",
"integer",
"#",
"max",
"value",
"}",
"this",
"is",
"to",
"match",
"the",
"behavior",
"of",
"d",
"f",
"s",
"input",
"stream",
"available",
"(",
")",
",",
"which",
"some",
"clients",
"may",
"rely",
"on",
"(",
"h",
"base",
"write",
"-",
"ahead",
"log",
"reading",
"in",
"particular",
")"
] |
[
"public",
"synchronized",
"int",
"available",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"closed",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"f",
"s",
"exception",
"messages",
"stream",
"is",
"closed",
")",
";",
"}",
"final",
"long",
"remaining",
"=",
"this",
"content",
"length",
"-",
"this",
"get",
"pos",
"(",
")",
";",
"return",
"remaining",
"<",
"=",
"integer",
"max",
"value",
"?",
"(",
"int",
")",
"remaining",
":",
"integer",
"max",
"value",
";",
"}"
] |
[
"generates",
"a",
"ca",
"certificate"
] |
[
"public",
"static",
"x",
"5",
"0",
"9",
"certificate",
"generate",
"c",
"a",
"certificate",
"(",
"x",
"5",
"0",
"0",
"principal",
"x",
"5",
"0",
"0",
"principal",
",",
"key",
"pair",
"key",
"pair",
",",
"int",
"days",
")",
"throws",
"operator",
"creation",
"exception",
",",
"certificate",
"exception",
",",
"cert",
"i",
"o",
"exception",
",",
"no",
"such",
"algorithm",
"exception",
"{",
"return",
"generate",
"signed",
"certificate",
"(",
"x",
"5",
"0",
"0",
"principal",
",",
"null",
",",
"key",
"pair",
",",
"null",
",",
"null",
",",
"true",
",",
"days",
",",
"null",
")",
";",
"}"
] |
[
"add",
"an",
"async",
"wait",
"operator"
] |
[
"private",
"static",
"<",
"in",
",",
"out",
">",
"single",
"output",
"stream",
"operator",
"<",
"out",
">",
"add",
"operator",
"(",
"data",
"stream",
"<",
"in",
">",
"in",
",",
"async",
"function",
"<",
"in",
",",
"out",
">",
"func",
",",
"long",
"timeout",
",",
"int",
"buf",
"size",
",",
"output",
"mode",
"mode",
")",
"{",
"type",
"information",
"<",
"out",
">",
"out",
"type",
"info",
"=",
"type",
"extractor",
"get",
"unary",
"operator",
"return",
"type",
"(",
"func",
",",
"async",
"function",
"class",
",",
"0",
",",
"1",
",",
"new",
"int",
"[",
"]",
"{",
"1",
",",
"0",
"}",
",",
"in",
"get",
"type",
"(",
")",
",",
"utils",
"get",
"call",
"location",
"name",
"(",
")",
",",
"true",
")",
";",
"/",
"/",
"create",
"transform",
"async",
"wait",
"operator",
"factory",
"<",
"in",
",",
"out",
">",
"operator",
"factory",
"=",
"new",
"async",
"wait",
"operator",
"factory",
"<",
">",
"(",
"in",
"get",
"execution",
"environment",
"(",
")",
"clean",
"(",
"func",
")",
",",
"timeout",
",",
"buf",
"size",
",",
"mode",
")",
";",
"return",
"in",
"transform",
"(",
"\"",
"async",
"wait",
"operator",
"\"",
",",
"out",
"type",
"info",
",",
"operator",
"factory",
")",
";",
"}"
] |
[
"adds",
"the",
"remaining",
"values",
"to",
"the",
"specified",
"array"
] |
[
"public",
"float",
"array",
"to",
"array",
"(",
"float",
"array",
"array",
")",
"{",
"while",
"(",
"has",
"next",
")",
"array",
"add",
"(",
"next",
"(",
")",
")",
";",
"return",
"array",
";",
"}"
] |
[
"get",
"the",
"{",
"@",
"link",
"counter",
"}",
"of",
"the",
"given",
"group",
"with",
"the",
"given",
"name"
] |
[
"public",
"abstract",
"counter",
"get",
"counter",
"(",
"enum",
"<",
"?",
">",
"name",
")",
";"
] |
[
"returns",
"the",
"character",
"at",
"the",
"current",
"index",
"and",
"then",
"increments",
"the",
"index",
"by",
"one",
"if",
"the",
"resulting",
"index",
"is",
"greater",
"or",
"equal",
"to",
"the",
"end",
"index",
",",
"the",
"current",
"index",
"is",
"reset",
"to",
"the",
"end",
"index",
"and",
"a",
"value",
"of",
"done",
"is",
"returned",
"also",
"adds",
"the",
"character",
"to",
"the",
"genericized",
"string"
] |
[
"public",
"char",
"get",
"and",
"increment",
"(",
")",
"{",
"char",
"c",
"=",
"super",
"get",
"and",
"increment",
"(",
")",
";",
"genericized",
"string",
"append",
"(",
"c",
")",
";",
"return",
"c",
";",
"}"
] |
[
"explicitly",
"tests",
"what",
"you",
"can",
"'",
"t",
"list",
"as",
"a",
"sort",
"value",
"what",
"you",
"can",
"list",
"is",
"tested",
"by",
"{",
"@",
"link",
"#",
"random",
"search",
"after",
"builder",
"(",
")",
"}"
] |
[
"public",
"void",
"test",
"bad",
"types",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"random",
"search",
"from",
"builder",
"with",
"sort",
"value",
"throws",
"(",
"new",
"object",
"(",
")",
")",
";",
"random",
"search",
"from",
"builder",
"with",
"sort",
"value",
"throws",
"(",
"new",
"geo",
"point",
"(",
"0",
",",
"0",
")",
")",
";",
"random",
"search",
"from",
"builder",
"with",
"sort",
"value",
"throws",
"(",
"random",
"search",
"after",
"builder",
"(",
")",
")",
";",
"random",
"search",
"from",
"builder",
"with",
"sort",
"value",
"throws",
"(",
"this",
")",
";",
"}"
] |
[
"called",
"when",
"an",
"item",
"has",
"been",
"dismissed",
"by",
"a",
"swipe",
"implementations",
"should",
"call",
"{",
"@",
"link",
"recycler",
"view",
"adapter",
"#",
"notify",
"item",
"removed",
"(",
"int",
")",
"}",
"after",
"adjusting",
"the",
"underlying",
"data",
"to",
"reflect",
"this",
"removal"
] |
[
"void",
"on",
"item",
"dismiss",
"(",
"int",
"position",
")",
";"
] |
[
"attribute",
"value",
"handler"
] |
[
"public",
"d",
"b",
"d",
"value",
"handler",
"get",
"value",
"handler",
"(",
")",
"{",
"return",
"value",
"handler",
";",
"}"
] |
[
"creates",
"a",
"temporary",
"directory",
"inside",
"the",
"directory",
"represented",
"by",
"'",
"this",
"'"
] |
[
"public",
"file",
"path",
"create",
"temp",
"dir",
"(",
"final",
"string",
"prefix",
",",
"final",
"string",
"suffix",
")",
"throws",
"i",
"o",
"exception",
",",
"interrupted",
"exception",
"{",
"try",
"{",
"string",
"[",
"]",
"s",
";",
"if",
"(",
"string",
"utils",
"is",
"blank",
"(",
"suffix",
")",
")",
"{",
"s",
"=",
"new",
"string",
"[",
"]",
"{",
"prefix",
",",
"\"",
"tmp",
"\"",
"}",
";",
"/",
"/",
"see",
"file",
"create",
"temp",
"file",
"-",
"tmp",
"is",
"used",
"if",
"suffix",
"is",
"null",
"}",
"else",
"{",
"s",
"=",
"new",
"string",
"[",
"]",
"{",
"prefix",
",",
"suffix",
"}",
";",
"}",
"string",
"name",
"=",
"string",
"utils",
"join",
"(",
"s",
",",
"\"",
"\"",
")",
";",
"return",
"new",
"file",
"path",
"(",
"this",
",",
"act",
"(",
"new",
"create",
"temp",
"dir",
"(",
"name",
")",
")",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"failed",
"to",
"create",
"a",
"temp",
"directory",
"on",
"\"",
"+",
"remote",
",",
"e",
")",
";",
"}",
"}"
] |
[
"performs",
"simple",
"authentication",
"against",
"the",
"specified",
"url",
"if",
"a",
"token",
"is",
"given",
"it",
"does",
"a",
"nop",
"and",
"returns",
"the",
"given",
"token",
"if",
"no",
"token",
"is",
"given",
",",
"it",
"will",
"perform",
"an",
"http",
"<",
"code",
">",
"options",
"<",
"code",
">",
"request",
"injecting",
"an",
"additional",
"parameter",
"{",
"@",
"link",
"#",
"user",
"name",
"}",
"in",
"the",
"query",
"string",
"with",
"the",
"value",
"returned",
"by",
"the",
"{",
"@",
"link",
"#",
"get",
"user",
"name",
"(",
")",
"}",
"method",
"if",
"the",
"response",
"is",
"successful",
"it",
"will",
"update",
"the",
"authentication",
"token"
] |
[
"public",
"void",
"authenticate",
"(",
"url",
"url",
",",
"authenticated",
"u",
"r",
"l",
"token",
"token",
")",
"throws",
"i",
"o",
"exception",
",",
"authentication",
"exception",
"{",
"string",
"str",
"url",
"=",
"url",
"to",
"string",
"(",
")",
";",
"string",
"param",
"separator",
"=",
"(",
"str",
"url",
"contains",
"(",
"\"",
"?",
"\"",
")",
")",
"?",
"\"",
"&",
"\"",
":",
"\"",
"?",
"\"",
";",
"str",
"url",
"+",
"=",
"param",
"separator",
"+",
"user",
"name",
"eq",
"+",
"get",
"user",
"name",
"(",
")",
";",
"url",
"=",
"new",
"url",
"(",
"str",
"url",
")",
";",
"http",
"u",
"r",
"l",
"connection",
"conn",
"=",
"token",
"open",
"connection",
"(",
"url",
",",
"conn",
"configurator",
")",
";",
"conn",
"set",
"request",
"method",
"(",
"\"",
"options",
"\"",
")",
";",
"conn",
"connect",
"(",
")",
";",
"authenticated",
"u",
"r",
"l",
"extract",
"token",
"(",
"conn",
",",
"token",
")",
";",
"}"
] |
[
"determines",
"the",
"address",
"set",
"that",
"flows",
"from",
"the",
"addresses",
"in",
"this",
"follow",
"flow",
"object",
"'",
"s",
"initial",
"addresses",
"set",
"the",
"address",
"set",
"is",
"determined",
"by",
"what",
"addresses",
"were",
"provided",
"when",
"the",
"follow",
"flow",
"was",
"constructed",
"and",
"the",
"type",
"of",
"flow",
"requested",
"this",
"method",
"follows",
"flows",
"in",
"the",
"forward",
"direction"
] |
[
"public",
"address",
"set",
"get",
"flow",
"address",
"set",
"(",
"task",
"monitor",
"monitor",
")",
"{",
"return",
"get",
"address",
"flow",
"(",
"monitor",
",",
"initial",
"addresses",
",",
"true",
")",
";",
"}"
] |
[
"returns",
"a",
"pseudorandom",
",",
"uniformly",
"distributed",
"{",
"@",
"code",
"double",
"}",
"value",
"between",
"0",
"(",
"inclusive",
")",
"and",
"the",
"specified",
"value",
"(",
"exclusive",
")"
] |
[
"public",
"double",
"next",
"double",
"(",
"double",
"n",
")",
"{",
"if",
"(",
"n",
"<",
"=",
"0",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"n",
"must",
"be",
"positive",
"\"",
")",
";",
"}",
"return",
"next",
"double",
"(",
")",
"*",
"n",
";",
"}"
] |
[
"fixes",
"up",
"any",
"chained",
"pointers",
",",
"starting",
"at",
"the",
"given",
"address"
] |
[
"private",
"list",
"<",
"address",
">",
"process",
"pointer",
"chain",
"(",
"address",
"chain",
"start",
",",
"long",
"next",
"off",
"size",
")",
"throws",
"memory",
"access",
"exception",
"{",
"list",
"<",
"address",
">",
"fixed",
"addresses",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"while",
"(",
"!",
"monitor",
"is",
"cancelled",
"(",
")",
")",
"{",
"long",
"chain",
"value",
"=",
"memory",
"get",
"long",
"(",
"chain",
"start",
")",
";",
"fixup",
"pointer",
"(",
"chain",
"start",
",",
"chain",
"value",
")",
";",
"fixed",
"addresses",
"add",
"(",
"chain",
"start",
")",
";",
"long",
"next",
"value",
"off",
"=",
"(",
"(",
"chain",
"value",
">",
">",
"51l",
")",
"&",
"0x",
"7ff",
"l",
")",
"*",
"next",
"off",
"size",
";",
"if",
"(",
"next",
"value",
"off",
"=",
"=",
"0",
")",
"{",
"break",
";",
"}",
"chain",
"start",
"=",
"chain",
"start",
"add",
"(",
"next",
"value",
"off",
")",
";",
"}",
"return",
"fixed",
"addresses",
";",
"}"
] |
[
"client",
"+",
"server",
"spans",
"that",
"don",
"'",
"t",
"share",
"i",
"ds",
"are",
"treated",
"as",
"server",
"spans",
"missing",
"their",
"peer"
] |
[
"@",
"test",
"void",
"links",
"single",
"host",
"spans",
"(",
")",
"{",
"list",
"<",
"span",
">",
"single",
"host",
"spans",
"=",
"as",
"list",
"(",
"span",
"(",
"\"",
"a",
"\"",
",",
"null",
",",
"\"",
"a",
"\"",
",",
"kind",
"client",
",",
"\"",
"web",
"\"",
",",
"null",
",",
"false",
")",
",",
"span",
"(",
"\"",
"a",
"\"",
",",
"\"",
"a",
"\"",
",",
"\"",
"b",
"\"",
",",
"kind",
"server",
",",
"\"",
"app",
"\"",
",",
"null",
",",
"false",
")",
")",
";",
"assert",
"that",
"(",
"new",
"dependency",
"linker",
"(",
")",
"put",
"trace",
"(",
"single",
"host",
"spans",
")",
"link",
"(",
")",
")",
"contains",
"only",
"(",
"dependency",
"link",
"new",
"builder",
"(",
")",
"parent",
"(",
"\"",
"web",
"\"",
")",
"child",
"(",
"\"",
"app",
"\"",
")",
"call",
"count",
"(",
"1l",
")",
"build",
"(",
")",
")",
";",
"}"
] |
[
"gets",
"all",
"common",
"file",
"extensions",
"of",
"supported",
"file",
"compression",
"formats"
] |
[
"public",
"static",
"collection",
"<",
"string",
">",
"get",
"common",
"suffixes",
"(",
")",
"{",
"return",
"common",
"suffixes",
";",
"}"
] |
[
"stops",
"decoder",
"thread",
"and",
"releases",
"frame",
"buffer",
"does",
"nothing",
"if",
"already",
"stopped"
] |
[
"public",
"void",
"stop",
"decoder",
"thread",
"(",
")",
"{",
"m",
"gif",
"info",
"handle",
"stop",
"decoder",
"thread",
"(",
")",
";",
"}"
] |
[
"get",
"the",
"address",
"referred",
"to",
"by",
"a",
"spacebase",
"reference",
"address",
"-",
"of",
"references",
"are",
"encoded",
"in",
"the",
"p",
"-",
"code",
"syntax",
"tree",
"as",
":",
"{",
"@",
"code",
"vn",
"=",
"ptrsub",
"(",
"<",
"spacebase",
">",
",",
"#",
"const",
")",
"}",
"this",
"decodes",
"the",
"reference",
"and",
"returns",
"the",
"address"
] |
[
"public",
"static",
"address",
"get",
"spacebase",
"reference",
"address",
"(",
"program",
"program",
",",
"pcode",
"op",
"op",
")",
"{",
"address",
"storage",
"address",
"=",
"null",
";",
"if",
"(",
"op",
"=",
"=",
"null",
")",
"{",
"return",
"storage",
"address",
";",
"}",
"if",
"(",
"op",
"get",
"opcode",
"(",
")",
"=",
"=",
"pcode",
"op",
"ptrsub",
")",
"{",
"varnode",
"vnode",
"=",
"op",
"get",
"input",
"(",
"0",
")",
";",
"if",
"(",
"vnode",
"is",
"register",
"(",
")",
")",
"{",
"address",
"space",
"stackspace",
"=",
"program",
"get",
"address",
"factory",
"(",
")",
"get",
"stack",
"space",
"(",
")",
";",
"if",
"(",
"stackspace",
"!",
"=",
"null",
")",
"{",
"address",
"caddr",
"=",
"op",
"get",
"input",
"(",
"1",
")",
"get",
"address",
"(",
")",
";",
"storage",
"address",
"=",
"stackspace",
"get",
"address",
"(",
"caddr",
"get",
"offset",
"(",
")",
")",
";",
"}",
"}",
"else",
"{",
"address",
"caddr",
"=",
"op",
"get",
"input",
"(",
"1",
")",
"get",
"address",
"(",
")",
";",
"storage",
"address",
"=",
"program",
"get",
"address",
"factory",
"(",
")",
"get",
"default",
"address",
"space",
"(",
")",
"get",
"address",
"(",
"caddr",
"get",
"offset",
"(",
")",
")",
";",
"}",
"}",
"return",
"storage",
"address",
";",
"}"
] |
[
"an",
"expectation",
"for",
"checking",
"that",
"all",
"elements",
"present",
"on",
"the",
"web",
"page",
"that",
"match",
"the",
"locator",
"are",
"visible",
"visibility",
"means",
"that",
"the",
"elements",
"are",
"not",
"only",
"displayed",
"but",
"also",
"have",
"a",
"height",
"and",
"width",
"that",
"is",
"greater",
"than",
"0"
] |
[
"public",
"static",
"expected",
"condition",
"<",
"list",
"<",
"web",
"element",
">",
">",
"visibility",
"of",
"all",
"elements",
"(",
"final",
"list",
"<",
"web",
"element",
">",
"elements",
")",
"{",
"return",
"new",
"expected",
"condition",
"<",
"list",
"<",
"web",
"element",
">",
">",
"(",
")",
"{",
"@",
"override",
"public",
"list",
"<",
"web",
"element",
">",
"apply",
"(",
"web",
"driver",
"driver",
")",
"{",
"for",
"(",
"web",
"element",
"element",
":",
"elements",
")",
"{",
"if",
"(",
"!",
"element",
"is",
"displayed",
"(",
")",
")",
"{",
"return",
"null",
";",
"}",
"}",
"return",
"elements",
"size",
"(",
")",
">",
"0",
"?",
"elements",
":",
"null",
";",
"}",
"@",
"override",
"public",
"string",
"to",
"string",
"(",
")",
"{",
"return",
"\"",
"visibility",
"of",
"all",
"\"",
"+",
"elements",
";",
"}",
"}",
";",
"}"
] |
[
"a",
"parser",
"for",
"the",
"contents",
"of",
"this",
"request",
"if",
"it",
"has",
"contents",
",",
"otherwise",
"a",
"parser",
"for",
"the",
"{",
"@",
"code",
"source",
"}",
"parameter",
"if",
"there",
"is",
"one",
",",
"otherwise",
"throws",
"an",
"{",
"@",
"link",
"elasticsearch",
"parse",
"exception",
"}",
"use",
"{",
"@",
"link",
"#",
"with",
"content",
"or",
"source",
"param",
"parser",
"or",
"null",
"(",
"checked",
"consumer",
")",
"}",
"instead",
"if",
"you",
"need",
"to",
"handle",
"the",
"absence",
"request",
"content",
"gracefully"
] |
[
"public",
"final",
"x",
"content",
"parser",
"content",
"or",
"source",
"param",
"parser",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"tuple",
"<",
"x",
"content",
"type",
",",
"bytes",
"reference",
">",
"tuple",
"=",
"content",
"or",
"source",
"param",
"(",
")",
";",
"return",
"tuple",
"v",
"1",
"(",
")",
"x",
"content",
"(",
")",
"create",
"parser",
"(",
"x",
"content",
"registry",
",",
"logging",
"deprecation",
"handler",
"instance",
",",
"tuple",
"v",
"2",
"(",
")",
"stream",
"input",
"(",
")",
")",
";",
"}"
] |
[
"tests",
"{",
"@",
"link",
"result",
"partition",
"#",
"get",
"available",
"future",
"(",
")",
"}"
] |
[
"public",
"void",
"test",
"is",
"available",
"or",
"not",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"int",
"num",
"all",
"buffers",
"=",
"10",
";",
"final",
"int",
"buffer",
"size",
"=",
"1024",
";",
"final",
"netty",
"shuffle",
"environment",
"network",
"=",
"new",
"netty",
"shuffle",
"environment",
"builder",
"(",
")",
"set",
"num",
"network",
"buffers",
"(",
"num",
"all",
"buffers",
")",
"set",
"buffer",
"size",
"(",
"buffer",
"size",
")",
"build",
"(",
")",
";",
"final",
"result",
"partition",
"result",
"partition",
"=",
"create",
"partition",
"(",
"network",
",",
"result",
"partition",
"type",
"pipelined",
",",
"1",
")",
";",
"try",
"{",
"result",
"partition",
"setup",
"(",
")",
";",
"result",
"partition",
"get",
"buffer",
"pool",
"(",
")",
"set",
"num",
"buffers",
"(",
"2",
")",
";",
"assert",
"true",
"(",
"result",
"partition",
"get",
"available",
"future",
"(",
")",
"is",
"done",
"(",
")",
")",
";",
"result",
"partition",
"emit",
"record",
"(",
"byte",
"buffer",
"allocate",
"(",
"buffer",
"size",
")",
",",
"0",
")",
";",
"result",
"partition",
"emit",
"record",
"(",
"byte",
"buffer",
"allocate",
"(",
"buffer",
"size",
")",
",",
"0",
")",
";",
"assert",
"false",
"(",
"result",
"partition",
"get",
"available",
"future",
"(",
")",
"is",
"done",
"(",
")",
")",
";",
"}",
"finally",
"{",
"result",
"partition",
"release",
"(",
")",
";",
"network",
"close",
"(",
")",
";",
"}",
"}"
] |
[
"set",
"the",
"target",
"linear",
"offset",
",",
"in",
"frame",
"a",
",",
"in",
"meters"
] |
[
"public",
"void",
"set",
"linear",
"offset",
"(",
"vec",
"2",
"linear",
"offset",
")",
"{",
"if",
"(",
"linear",
"offset",
"x",
"!",
"=",
"m",
"linear",
"offset",
"x",
"|",
"|",
"linear",
"offset",
"y",
"!",
"=",
"m",
"linear",
"offset",
"y",
")",
"{",
"m",
"body",
"a",
"set",
"awake",
"(",
"true",
")",
";",
"m",
"body",
"b",
"set",
"awake",
"(",
"true",
")",
";",
"m",
"linear",
"offset",
"set",
"(",
"linear",
"offset",
")",
";",
"}",
"}"
] |
[
"releases",
"this",
"lock",
",",
"since",
"you",
"are",
"through",
"with",
"the",
"code",
"that",
"needed",
"synchronization"
] |
[
"public",
"synchronized",
"void",
"release",
"(",
")",
"{",
"thread",
"curr",
"thread",
"=",
"thread",
"current",
"thread",
"(",
")",
";",
"if",
"(",
"lock",
"aquire",
"count",
">",
"0",
"&",
"&",
"(",
"owner",
"=",
"=",
"curr",
"thread",
")",
")",
"{",
"if",
"(",
"-",
"-",
"lock",
"aquire",
"count",
"=",
"=",
"0",
")",
"{",
"owner",
"=",
"null",
";",
"/",
"/",
"this",
"is",
"purely",
"to",
"help",
"sample",
"profiling",
"if",
"notify",
"(",
")",
"is",
"called",
"the",
"/",
"/",
"sampler",
"can",
"attribute",
"time",
"to",
"the",
"methods",
"calling",
"this",
"erroneously",
"for",
"some",
"reason",
"/",
"/",
"the",
"visualvm",
"sampler",
"gets",
"a",
"sample",
"more",
"often",
"when",
"notify",
"(",
")",
"is",
"called",
"if",
"(",
"waiter",
"count",
"!",
"=",
"0",
")",
"{",
"notify",
"(",
")",
";",
"}",
"}",
"}",
"else",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"attempted",
"to",
"release",
"an",
"unowned",
"lock",
":",
"\"",
"+",
"name",
")",
";",
"}",
"}"
] |
[
"return",
"the",
"current",
"{",
"@",
"link",
"connection",
"}",
"held",
"by",
"this",
"{",
"@",
"link",
"connection",
"holder",
"}",
"this",
"will",
"be",
"the",
"same",
"{",
"@",
"link",
"connection",
"}",
"until",
"{",
"@",
"code",
"released",
"}",
"gets",
"called",
"on",
"the",
"{",
"@",
"link",
"connection",
"holder",
"}",
",",
"which",
"will",
"reset",
"the",
"held",
"{",
"@",
"link",
"connection",
"}",
",",
"fetching",
"a",
"new",
"{",
"@",
"link",
"connection",
"}",
"on",
"demand"
] |
[
"public",
"connection",
"get",
"connection",
"(",
")",
"{",
"assert",
"not",
"null",
"(",
"this",
"current",
"connection",
",",
"\"",
"active",
"connection",
"is",
"required",
"\"",
")",
";",
"return",
"this",
"current",
"connection",
";",
"}"
] |
[
"sets",
"a",
"new",
"root",
"{",
"@",
"link",
"node",
"}",
"which",
"should",
"be",
"rendered"
] |
[
"public",
"render",
"core",
"test",
"rule",
"use",
"root",
"node",
"(",
"node",
"root",
"node",
")",
"{",
"this",
"root",
"node",
"=",
"root",
"node",
";",
"return",
"this",
";",
"}"
] |
[
"return",
"information",
"about",
"this",
"context"
] |
[
"public",
"string",
"to",
"string",
"(",
")",
"{",
"string",
"builder",
"sb",
"=",
"new",
"string",
"builder",
"(",
"get",
"display",
"name",
"(",
")",
")",
";",
"sb",
"append",
"(",
"\"",
",",
"started",
"on",
"\"",
")",
"append",
"(",
"new",
"date",
"(",
"get",
"startup",
"date",
"(",
")",
")",
")",
";",
"application",
"context",
"parent",
"=",
"get",
"parent",
"(",
")",
";",
"if",
"(",
"parent",
"!",
"=",
"null",
")",
"{",
"sb",
"append",
"(",
"\"",
",",
"parent",
":",
"\"",
")",
"append",
"(",
"parent",
"get",
"display",
"name",
"(",
")",
")",
";",
"}",
"return",
"sb",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"find",
"the",
"fields",
"constant",
"that",
"matches",
"name",
",",
"or",
"null",
"if",
"its",
"not",
"found"
] |
[
"public",
"static",
"fields",
"find",
"by",
"name",
"(",
"string",
"name",
")",
"{",
"return",
"by",
"name",
"get",
"(",
"name",
")",
";",
"}"
] |
[
"set",
"the",
"timeout",
"in",
"milliseconds",
"for",
"this",
"operation",
"or",
"{",
"@",
"code",
"null",
"}",
"if",
"the",
"default",
"api",
"timeout",
"for",
"the",
"admin",
"client",
"should",
"be",
"used"
] |
[
"public",
"delete",
"acls",
"options",
"timeout",
"ms",
"(",
"integer",
"timeout",
"ms",
")",
"{",
"this",
"timeout",
"ms",
"=",
"timeout",
"ms",
";",
"return",
"this",
";",
"}"
] |
[
"main",
"game",
"loop",
"this",
"loop",
"will",
"always",
"run",
"until",
"the",
"game",
"is",
"over",
"for",
"each",
"loop",
"it",
"will",
"process",
"user",
"input",
",",
"update",
"internal",
"status",
",",
"and",
"render",
"the",
"next",
"frames",
"for",
"more",
"detail",
"please",
"refer",
"to",
"the",
"game",
"-",
"loop",
"pattern"
] |
[
"private",
"void",
"game",
"loop",
"(",
")",
"{",
"while",
"(",
"is",
"running",
")",
"{",
"process",
"input",
"(",
")",
";",
"update",
"(",
")",
";",
"render",
"(",
")",
";",
"}",
"}"
] |
[
"whether",
"the",
"table",
"is",
"temporary"
] |
[
"boolean",
"is",
"temporary",
"(",
")",
";"
] |
[
"computes",
"the",
"estimates",
"for",
"the",
"flat",
"map",
"operator",
"since",
"it",
"un",
"-",
"nests",
",",
"we",
"assume",
"a",
"cardinality",
"increase",
"to",
"give",
"the",
"system",
"a",
"hint",
"at",
"data",
"increase",
",",
"we",
"take",
"a",
"default",
"magic",
"number",
"of",
"a",
"5",
"times",
"increase"
] |
[
"protected",
"void",
"compute",
"operator",
"specific",
"default",
"estimates",
"(",
"data",
"statistics",
"statistics",
")",
"{",
"this",
"estimated",
"num",
"records",
"=",
"get",
"predecessor",
"node",
"(",
")",
"get",
"estimated",
"num",
"records",
"(",
")",
"*",
"5",
";",
"}"
] |
[
"called",
"to",
"trigger",
"the",
"rebuilt",
"of",
"the",
"plugin",
"'",
"s",
"internal",
"members",
"the",
"reload",
"operation",
"<",
"b",
">",
"is",
"required",
"to",
"have",
"been",
"completed",
"<",
"b",
">",
"when",
"the",
"method",
"returns",
"strictly",
"speaking",
",",
"the",
"<",
"code",
">",
"settings",
"<",
"code",
">",
"argument",
"should",
"not",
"be",
"accessed",
"outside",
"of",
"this",
"method",
"'",
"s",
"call",
"stack",
",",
"as",
"any",
"values",
"stored",
"in",
"the",
"node",
"'",
"s",
"keystore",
"(",
"see",
"{",
"@",
"code",
"secure",
"setting",
"}",
")",
"will",
"not",
"otherwise",
"be",
"retrievable",
"the",
"setting",
"values",
"do",
"not",
"follow",
"dynamic",
"updates",
",",
"i",
"e",
"the",
"values",
"are",
"identical",
"to",
"the",
"ones",
"during",
"the",
"initial",
"plugin",
"loading",
",",
"barring",
"the",
"keystore",
"file",
"on",
"disk",
"changes",
"any",
"failure",
"during",
"the",
"operation",
"should",
"be",
"signaled",
"by",
"raising",
"an",
"exception",
",",
"but",
"the",
"plugin",
"should",
"otherwise",
"continue",
"to",
"function",
"unperturbed"
] |
[
"void",
"reload",
"(",
"settings",
"settings",
")",
"throws",
"exception",
";"
] |
[
"prepare",
"saml",
"outbound",
"protocol",
"message",
"signing",
"handler"
] |
[
"protected",
"<",
"t",
"extends",
"s",
"a",
"m",
"l",
"object",
">",
"void",
"prepare",
"saml",
"outbound",
"protocol",
"message",
"signing",
"handler",
"(",
"final",
"message",
"context",
"outbound",
"context",
")",
"throws",
"exception",
"{",
"logger",
"trace",
"(",
"\"",
"attempting",
"to",
"sign",
"the",
"outbound",
"saml",
"message",
"\"",
")",
";",
"val",
"handler",
"=",
"new",
"s",
"a",
"m",
"l",
"outbound",
"protocol",
"message",
"signing",
"handler",
"(",
")",
";",
"handler",
"set",
"sign",
"error",
"responses",
"(",
"cas",
"properties",
"get",
"authn",
"(",
")",
"get",
"saml",
"idp",
"(",
")",
"get",
"response",
"(",
")",
"is",
"sign",
"error",
"(",
")",
")",
";",
"handler",
"invoke",
"(",
"outbound",
"context",
")",
";",
"logger",
"debug",
"(",
"\"",
"signed",
"saml",
"message",
"successfully",
"\"",
")",
";",
"}"
] |
[
"get",
"outer",
"enum"
] |
[
"public",
"outer",
"enum",
"get",
"outer",
"enum",
"(",
")",
"{",
"return",
"outer",
"enum",
";",
"}"
] |
[
"gets",
"a",
"64",
"-",
"bit",
"integer",
"at",
"the",
"current",
"{",
"@",
"code",
"reader",
"index",
"}",
"and",
"increases",
"the",
"{",
"@",
"code",
"reader",
"index",
"}",
"by",
"{",
"@",
"code",
"8",
"}",
"in",
"this",
"buffer"
] |
[
"public",
"abstract",
"long",
"read",
"long",
"(",
")",
";"
] |
[
"returns",
"true",
"if",
"this",
"{",
"@",
"link",
"executor",
"}",
"is",
"ready",
"for",
"action"
] |
[
"public",
"boolean",
"is",
"idle",
"(",
")",
"{",
"lock",
"read",
"lock",
"(",
")",
"lock",
"(",
")",
";",
"try",
"{",
"return",
"work",
"unit",
"=",
"=",
"null",
"&",
"&",
"executable",
"=",
"=",
"null",
";",
"}",
"finally",
"{",
"lock",
"read",
"lock",
"(",
")",
"unlock",
"(",
")",
";",
"}",
"}"
] |
[
"get",
"{",
"@",
"link",
"application",
"id",
"}",
"of",
"the",
"application",
"being",
"stopped"
] |
[
"public",
"application",
"id",
"get",
"application",
"id",
"(",
")",
"{",
"return",
"this",
"application",
"id",
";",
"}"
] |
[
"creates",
"a",
"new",
"default",
"data",
"organization",
"this",
"has",
"a",
"mapping",
"which",
"defines",
"the",
"alignment",
"of",
"a",
"data",
"type",
"based",
"on",
"its",
"size",
"the",
"map",
"defines",
"pairs",
"for",
"data",
"types",
"that",
"are",
"1",
",",
"2",
",",
"4",
",",
"and",
"8",
"bytes",
"in",
"length"
] |
[
"public",
"static",
"data",
"organization",
"get",
"default",
"organization",
"(",
")",
"{",
"return",
"get",
"default",
"organization",
"(",
"null",
")",
";",
"}"
] |
[
"if",
"somebody",
"is",
"unlucky",
"enough",
"to",
"have",
"to",
"serialize",
"one",
"of",
"these",
",",
"serialize",
"it",
"as",
"a",
"linked",
"hash",
"map",
"so",
"that",
"they",
"won",
"'",
"t",
"need",
"gson",
"on",
"the",
"other",
"side",
"to",
"deserialize",
"it",
"using",
"serialization",
"defeats",
"our",
"do",
"s",
"defence",
",",
"so",
"most",
"apps",
"shouldn",
"'",
"t",
"use",
"it"
] |
[
"private",
"object",
"write",
"replace",
"(",
")",
"throws",
"object",
"stream",
"exception",
"{",
"return",
"new",
"linked",
"hash",
"map",
"<",
">",
"(",
"this",
")",
";",
"}"
] |
[
"creates",
"a",
"new",
"drawable",
"that",
"renders",
"the",
"same",
"as",
"this",
"drawable",
"tinted",
"the",
"specified",
"color"
] |
[
"public",
"nine",
"patch",
"drawable",
"tint",
"(",
"color",
"tint",
")",
"{",
"nine",
"patch",
"drawable",
"drawable",
"=",
"new",
"nine",
"patch",
"drawable",
"(",
"this",
")",
";",
"drawable",
"patch",
"=",
"new",
"nine",
"patch",
"(",
"drawable",
"get",
"patch",
"(",
")",
",",
"tint",
")",
";",
"return",
"drawable",
";",
"}"
] |
[
"validates",
"the",
"options",
"for",
"this",
"build",
"request",
"issues",
"warnings",
"for",
"the",
"use",
"of",
"deprecated",
"options",
",",
"and",
"warnings",
"or",
"errors",
"for",
"any",
"option",
"settings",
"that",
"conflict"
] |
[
"public",
"void",
"validate",
"options",
"(",
"build",
"request",
"request",
")",
"{",
"for",
"(",
"string",
"issue",
":",
"request",
"validate",
"options",
"(",
")",
")",
"{",
"get",
"reporter",
"(",
")",
"handle",
"(",
"event",
"warn",
"(",
"issue",
")",
")",
";",
"}",
"}"
] |
[
"get",
"array",
"item"
] |
[
"public",
"list",
"<",
"integer",
">",
"get",
"array",
"item",
"(",
")",
"{",
"return",
"array",
"item",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.