docstring_tokens
list | code_tokens
list |
|---|---|
[
"a",
"container",
"is",
"finishing",
"on",
"this",
"node",
"manager",
"this",
"is",
"a",
"signal",
"to",
"this",
"{",
"@",
"link",
"auxiliary",
"service",
"}",
"about",
"the",
"same"
] |
[
"public",
"void",
"stop",
"container",
"(",
"container",
"termination",
"context",
"stop",
"container",
"context",
")",
"{",
"}"
] |
[
"resets",
"the",
"data",
"that",
"the",
"buffer",
"reads"
] |
[
"public",
"void",
"reset",
"(",
"byte",
"[",
"]",
"input",
",",
"int",
"length",
")",
"{",
"buffer",
"reset",
"(",
"input",
",",
"0",
",",
"length",
")",
";",
"}"
] |
[
"makes",
"sure",
"every",
"link",
"works"
] |
[
"public",
"void",
"links",
"(",
")",
"throws",
"exception",
"{",
"web",
"client",
"wc",
"=",
"j",
"create",
"web",
"client",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
";",
"i",
"+",
"+",
")",
"{",
"html",
"page",
"page",
"=",
"wc",
"go",
"to",
"(",
"\"",
"manage",
"\"",
")",
";",
"list",
"<",
"?",
">",
"anchors",
"=",
"dom",
"node",
"util",
"select",
"nodes",
"(",
"page",
",",
"\"",
"/",
"/",
"div",
"[",
"contains",
"(",
"@",
"class",
",",
"'",
"manage",
"-",
"option",
"'",
")",
"]",
"/",
"a",
"[",
"not",
"(",
"@",
"onclick",
")",
"]",
"\"",
")",
";",
"assert",
"true",
"(",
"anchors",
"size",
"(",
")",
">",
"=",
"8",
")",
";",
"if",
"(",
"i",
"=",
"=",
"anchors",
"size",
"(",
")",
")",
"return",
";",
"/",
"/",
"done",
"(",
"(",
"html",
"anchor",
")",
"anchors",
"get",
"(",
"i",
")",
")",
"click",
"(",
")",
";",
"}",
"}"
] |
[
"sets",
"the",
"alignment",
"of",
"all",
"widgets",
"within",
"the",
"horizontal",
"group",
"set",
"to",
"{",
"@",
"link",
"align",
"#",
"center",
"}",
",",
"{",
"@",
"link",
"align",
"#",
"top",
"}",
",",
"{",
"@",
"link",
"align",
"#",
"bottom",
"}",
",",
"{",
"@",
"link",
"align",
"#",
"left",
"}",
",",
"{",
"@",
"link",
"align",
"#",
"right",
"}",
",",
"or",
"any",
"combination",
"of",
"those"
] |
[
"public",
"horizontal",
"group",
"align",
"(",
"int",
"align",
")",
"{",
"this",
"align",
"=",
"align",
";",
"return",
"this",
";",
"}"
] |
[
"get",
"the",
"cookie",
"value",
"associated",
"with",
"the",
"cookie",
"name"
] |
[
"string",
"get",
"cookie",
"value",
"(",
"t",
"request",
",",
"string",
"cookie",
"name",
")",
";"
] |
[
"encodes",
"the",
"specified",
"byte",
"array",
"into",
"a",
"string",
"using",
"the",
"{",
"@",
"link",
"base",
"6",
"4",
"}",
"encoding",
"scheme",
"this",
"method",
"first",
"encodes",
"all",
"input",
"bytes",
"into",
"a",
"base",
"6",
"4",
"encoded",
"byte",
"array",
"and",
"then",
"constructs",
"a",
"new",
"string",
"by",
"using",
"the",
"encoded",
"byte",
"array",
"and",
"the",
"{",
"@",
"link",
"java",
"nio",
"charset",
"standard",
"charsets",
"#",
"iso",
"8859",
"1",
"iso",
"-",
"8859",
"-",
"1",
"}",
"charset",
"in",
"other",
"words",
",",
"an",
"invocation",
"of",
"this",
"method",
"has",
"exactly",
"the",
"same",
"effect",
"as",
"invoking",
"{",
"@",
"code",
"new",
"string",
"(",
"encode",
"(",
"src",
")",
",",
"standard",
"charsets",
"iso",
"8859",
"1",
")",
"}"
] |
[
"public",
"string",
"encode",
"to",
"string",
"(",
"byte",
"[",
"]",
"src",
")",
"{",
"byte",
"[",
"]",
"encoded",
"=",
"encode",
"(",
"src",
")",
";",
"return",
"new",
"string",
"(",
"encoded",
",",
"0",
",",
"0",
",",
"encoded",
"length",
")",
";",
"}"
] |
[
"register",
"a",
"listener",
"that",
"will",
"be",
"called",
"when",
"this",
"model",
"visibility",
"state",
"has",
"changed",
"the",
"listener",
"will",
"contribute",
"to",
"this",
"model",
"'",
"s",
"hash",
"code",
"state",
"per",
"the",
"{",
"@",
"link",
"com",
"airbnb",
"epoxy",
"epoxy",
"attribute",
"option",
"#",
"do",
"not",
"hash",
"}",
"rules"
] |
[
"public",
"text",
"prop",
"default",
"view",
"model",
"on",
"visibility",
"state",
"changed",
"(",
"on",
"model",
"visibility",
"state",
"changed",
"listener",
"<",
"text",
"prop",
"default",
"view",
"model",
",",
"text",
"prop",
"default",
"view",
">",
"listener",
")",
"{",
"on",
"mutation",
"(",
")",
";",
"this",
"on",
"model",
"visibility",
"state",
"changed",
"listener",
"epoxy",
"generated",
"model",
"=",
"listener",
";",
"return",
"this",
";",
"}"
] |
[
"returns",
"the",
"(",
"possibly",
"null",
")",
"reference",
"wrapped",
"by",
"this",
"instance"
] |
[
"public",
"@",
"nullable",
"t",
"get",
"(",
")",
"{",
"return",
"reference",
";",
"}"
] |
[
"handle",
"the",
"case",
"of",
"underflow",
"caused",
"by",
"needing",
"more",
"input",
"characters"
] |
[
"private",
"void",
"read",
"more",
"chars",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"/",
"possibilities",
":",
"/",
"/",
"1",
")",
"array",
"has",
"space",
"available",
"on",
"right",
"hand",
"side",
"(",
"between",
"limit",
"and",
"capacity",
")",
"/",
"/",
"2",
")",
"array",
"has",
"space",
"available",
"on",
"left",
"hand",
"side",
"(",
"before",
"position",
")",
"/",
"/",
"3",
")",
"array",
"has",
"no",
"space",
"available",
"/",
"/",
"/",
"/",
"in",
"case",
"2",
"we",
"shift",
"the",
"existing",
"chars",
"to",
"the",
"left",
",",
"and",
"in",
"case",
"3",
"we",
"create",
"a",
"bigger",
"/",
"/",
"array",
",",
"then",
"they",
"both",
"become",
"case",
"1",
"if",
"(",
"available",
"capacity",
"(",
"char",
"buffer",
")",
"=",
"=",
"0",
")",
"{",
"if",
"(",
"char",
"buffer",
"position",
"(",
")",
">",
"0",
")",
"{",
"/",
"/",
"(",
"2",
")",
"there",
"is",
"room",
"in",
"the",
"buffer",
"move",
"existing",
"bytes",
"to",
"the",
"beginning",
"java",
"8",
"compatibility",
"flip",
"(",
"char",
"buffer",
"compact",
"(",
")",
")",
";",
"}",
"else",
"{",
"/",
"/",
"(",
"3",
")",
"entire",
"buffer",
"is",
"full",
",",
"need",
"bigger",
"buffer",
"char",
"buffer",
"=",
"grow",
"(",
"char",
"buffer",
")",
";",
"}",
"}",
"/",
"/",
"(",
"1",
")",
"read",
"more",
"characters",
"into",
"free",
"space",
"at",
"end",
"of",
"array",
"int",
"limit",
"=",
"char",
"buffer",
"limit",
"(",
")",
";",
"int",
"num",
"chars",
"=",
"reader",
"read",
"(",
"char",
"buffer",
"array",
"(",
")",
",",
"limit",
",",
"available",
"capacity",
"(",
"char",
"buffer",
")",
")",
";",
"if",
"(",
"num",
"chars",
"=",
"=",
"-",
"1",
")",
"{",
"end",
"of",
"input",
"=",
"true",
";",
"}",
"else",
"{",
"java",
"8",
"compatibility",
"limit",
"(",
"char",
"buffer",
",",
"limit",
"+",
"num",
"chars",
")",
";",
"}",
"}"
] |
[
"returns",
"the",
"name",
"of",
"the",
"file",
"containing",
"this",
"location"
] |
[
"public",
"string",
"file",
"(",
")",
"{",
"return",
"file",
";",
"}"
] |
[
"run",
"a",
"command",
"on",
"this",
"local",
"node",
"throws",
"an",
"exception",
"if",
"the",
"command",
"could",
"not",
"be",
"run",
",",
"or",
"if",
"the",
"command",
"returned",
"a",
"non",
"-",
"zero",
"error",
"status"
] |
[
"string",
"run",
"command",
"(",
"string",
"[",
"]",
"command",
")",
"throws",
"i",
"o",
"exception",
";"
] |
[
"set",
"the",
"tag",
"displayed",
"along",
"with",
"an",
"assertion",
"failure",
"'",
"s",
"other",
"state",
"information",
"history",
":",
"2",
"0",
"7",
"-",
"experimental"
] |
[
"public",
"final",
"u",
"with",
"tag",
"(",
"@",
"nullable",
"char",
"sequence",
"tag",
")",
"{",
"this",
"tag",
"=",
"tag",
";",
"return",
"(",
"u",
")",
"this",
";",
"}"
] |
[
"get",
"string",
"item"
] |
[
"public",
"string",
"get",
"string",
"item",
"(",
")",
"{",
"return",
"string",
"item",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}",
"if",
"the",
"given",
"path",
"is",
"a",
"symlink",
"(",
"mount",
"link",
")",
",",
"the",
"path",
"will",
"be",
"resolved",
"to",
"a",
"target",
"path",
"and",
"it",
"will",
"get",
"the",
"resolved",
"path",
"'",
"s",
"file",
"status",
"object",
"it",
"will",
"not",
"be",
"represented",
"as",
"a",
"symlink",
"and",
"is",
"directory",
"api",
"returns",
"true",
"if",
"the",
"resolved",
"path",
"is",
"a",
"directory",
",",
"false",
"otherwise"
] |
[
"public",
"file",
"status",
"get",
"file",
"status",
"(",
"final",
"path",
"f",
")",
"throws",
"access",
"control",
"exception",
",",
"file",
"not",
"found",
"exception",
",",
"unresolved",
"link",
"exception",
",",
"i",
"o",
"exception",
"{",
"inode",
"tree",
"resolve",
"result",
"<",
"abstract",
"file",
"system",
">",
"res",
"=",
"fs",
"state",
"resolve",
"(",
"get",
"uri",
"path",
"(",
"f",
")",
",",
"true",
")",
";",
"/",
"/",
"file",
"status",
"#",
"get",
"path",
"is",
"a",
"fully",
"qualified",
"path",
"relative",
"to",
"the",
"root",
"of",
"/",
"/",
"target",
"file",
"system",
"/",
"/",
"we",
"need",
"to",
"change",
"it",
"to",
"viewfs",
"uri",
"-",
"relative",
"to",
"root",
"of",
"mount",
"table",
"/",
"/",
"the",
"implementors",
"of",
"raw",
"local",
"file",
"system",
"were",
"trying",
"to",
"be",
"very",
"smart",
"/",
"/",
"they",
"implement",
"file",
"status",
"#",
"get",
"owener",
"lazily",
"-",
"-",
"the",
"object",
"/",
"/",
"returned",
"is",
"really",
"a",
"raw",
"local",
"file",
"system",
"that",
"expect",
"the",
"/",
"/",
"file",
"status",
"#",
"get",
"path",
"to",
"be",
"unchanged",
"so",
"that",
"it",
"can",
"get",
"owner",
"when",
"needed",
"/",
"/",
"hence",
"we",
"need",
"to",
"interpose",
"a",
"new",
"view",
"fs",
"file",
"status",
"that",
"works",
"around",
"file",
"status",
"status",
"=",
"res",
"target",
"file",
"system",
"get",
"file",
"status",
"(",
"res",
"remaining",
"path",
")",
";",
"return",
"new",
"view",
"fs",
"file",
"status",
"(",
"status",
",",
"this",
"make",
"qualified",
"(",
"f",
")",
")",
";",
"}"
] |
[
"object",
"to",
"byte",
"array"
] |
[
"public",
"static",
"byte",
"[",
"]",
"to",
"bytes",
"(",
"object",
"obj",
")",
"{",
"if",
"(",
"obj",
"=",
"=",
"null",
")",
"{",
"return",
"empty",
";",
"}",
"return",
"to",
"bytes",
"(",
"string",
"value",
"of",
"(",
"obj",
")",
")",
";",
"}"
] |
[
"check",
"if",
"the",
"driver",
"is",
"ready",
"to",
"be",
"used"
] |
[
"public",
"boolean",
"is",
"driver",
"ready",
"(",
")",
"{",
"return",
"this",
"driver",
"is",
"driver",
"ready",
"(",
")",
";",
"}"
] |
[
"should",
"an",
"id",
"be",
"generated",
"instead",
"of",
"read",
"from",
"the",
"passed",
"in",
"{",
"@",
"link",
"element",
"}",
"?",
"disabled",
"by",
"default",
";",
"subclasses",
"can",
"override",
"this",
"to",
"enable",
"id",
"generation",
"note",
"that",
"this",
"flag",
"is",
"about",
"always",
"generating",
"an",
"id",
";",
"the",
"parser",
"won",
"'",
"t",
"even",
"check",
"for",
"an",
"\"",
"id",
"\"",
"attribute",
"in",
"this",
"case"
] |
[
"protected",
"boolean",
"should",
"generate",
"id",
"(",
")",
"{",
"return",
"false",
";",
"}"
] |
[
"returns",
"the",
"frame",
"pointer",
"omission",
"data"
] |
[
"public",
"list",
"<",
"frame",
"pointer",
"omission",
"record",
">",
"get",
"frame",
"pointer",
"omission",
"data",
"(",
")",
"{",
"return",
"frame",
"pointer",
"omission",
"data",
";",
"}",
"/",
"/"
] |
[
"test",
"counter",
"won",
"'",
"t",
"count",
"down",
"incorrectly",
"when",
"invoker",
"is",
"destroyed",
"for",
"multiple",
"times"
] |
[
"public",
"void",
"test",
"multi",
"destory",
"(",
")",
"{",
"init",
"(",
"0",
",",
"1",
")",
";",
"dubbo",
"appender",
"do",
"start",
"(",
")",
";",
"dubbo",
"appender",
"clear",
"(",
")",
";",
"demo",
"service",
"invoker",
"destroy",
"(",
")",
";",
"demo",
"service",
"invoker",
"destroy",
"(",
")",
";",
"assertions",
"assert",
"equals",
"(",
"\"",
"hello",
"\"",
",",
"hello",
"service",
"hello",
"(",
")",
")",
";",
"assertions",
"assert",
"equals",
"(",
"0",
",",
"log",
"util",
"find",
"message",
"(",
"error",
"msg",
")",
",",
"\"",
"should",
"not",
"warning",
"message",
"\"",
")",
";",
"log",
"util",
"check",
"no",
"error",
"(",
")",
";",
"dubbo",
"appender",
"do",
"stop",
"(",
")",
";",
"destoy",
"(",
")",
";",
"}"
] |
[
"tests",
"that",
"saslplain",
"clients",
"with",
"missing",
"password",
"in",
"jaas",
"configuration",
"fail",
"authentication"
] |
[
"public",
"void",
"test",
"missing",
"password",
"sasl",
"plain",
"(",
")",
"throws",
"exception",
"{",
"string",
"node",
"=",
"\"",
"0",
"\"",
";",
"test",
"jaas",
"config",
"jaas",
"config",
"=",
"configure",
"mechanisms",
"(",
"\"",
"plain",
"\"",
",",
"arrays",
"as",
"list",
"(",
"\"",
"plain",
"\"",
")",
")",
";",
"jaas",
"config",
"set",
"client",
"options",
"(",
"\"",
"plain",
"\"",
",",
"\"",
"myuser",
"\"",
",",
"null",
")",
";",
"security",
"protocol",
"security",
"protocol",
"=",
"security",
"protocol",
"sasl",
"ssl",
";",
"server",
"=",
"create",
"echo",
"server",
"(",
"security",
"protocol",
")",
";",
"create",
"selector",
"(",
"security",
"protocol",
",",
"sasl",
"client",
"configs",
")",
";",
"inet",
"socket",
"address",
"addr",
"=",
"new",
"inet",
"socket",
"address",
"(",
"\"",
"127",
"0",
"0",
"1",
"\"",
",",
"server",
"port",
"(",
")",
")",
";",
"try",
"{",
"selector",
"connect",
"(",
"node",
",",
"addr",
",",
"buffer",
"size",
",",
"buffer",
"size",
")",
";",
"fail",
"(",
"\"",
"sasl",
"/",
"plain",
"channel",
"created",
"without",
"password",
"\"",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"/",
"/",
"expected",
"exception",
"}",
"}"
] |
[
"sets",
"the",
"player",
"to",
"be",
"connected",
"to",
"the",
"media",
"session",
"must",
"be",
"called",
"on",
"the",
"same",
"thread",
"that",
"is",
"used",
"to",
"access",
"the",
"player"
] |
[
"public",
"void",
"set",
"player",
"(",
"@",
"nullable",
"player",
"player",
")",
"{",
"assertions",
"check",
"argument",
"(",
"player",
"=",
"=",
"null",
"|",
"|",
"player",
"get",
"application",
"looper",
"(",
")",
"=",
"=",
"looper",
")",
";",
"if",
"(",
"this",
"player",
"!",
"=",
"null",
")",
"{",
"this",
"player",
"remove",
"listener",
"(",
"component",
"listener",
")",
";",
"}",
"this",
"player",
"=",
"player",
";",
"if",
"(",
"player",
"!",
"=",
"null",
")",
"{",
"player",
"add",
"listener",
"(",
"component",
"listener",
")",
";",
"}",
"invalidate",
"media",
"session",
"playback",
"state",
"(",
")",
";",
"invalidate",
"media",
"session",
"metadata",
"(",
")",
";",
"}"
] |
[
"return",
"a",
"map",
"of",
"vendor",
"-",
"specific",
"jpa",
"properties",
"for",
"the",
"given",
"persistence",
"unit",
",",
"typically",
"based",
"on",
"settings",
"in",
"this",
"jpa",
"vendor",
"adapter",
"instance",
"note",
"that",
"there",
"might",
"be",
"further",
"jpa",
"properties",
"defined",
"on",
"the",
"entity",
"manager",
"factory",
"bean",
",",
"which",
"might",
"potentially",
"override",
"individual",
"jpa",
"property",
"values",
"specified",
"here",
"this",
"implementation",
"delegates",
"to",
"{",
"@",
"link",
"#",
"get",
"jpa",
"property",
"map",
"(",
")",
"}",
"for",
"non",
"-",
"unit",
"-",
"dependent",
"properties",
"effectively",
",",
"this",
"persistence",
"unit",
"info",
"-",
"based",
"variant",
"only",
"needs",
"to",
"be",
"implemented",
"if",
"there",
"is",
"an",
"actual",
"need",
"to",
"react",
"to",
"unit",
"-",
"specific",
"characteristics",
"such",
"as",
"the",
"transaction",
"type",
"<",
"b",
">",
"note",
":",
"<",
"b",
">",
"this",
"variant",
"will",
"only",
"be",
"invoked",
"in",
"case",
"of",
"java",
"ee",
"style",
"container",
"bootstrapping",
"where",
"a",
"{",
"@",
"link",
"persistence",
"unit",
"info",
"}",
"is",
"present",
"(",
"i",
"e",
"{",
"@",
"link",
"local",
"container",
"entity",
"manager",
"factory",
"bean",
"}",
"in",
"case",
"of",
"simple",
"java",
"se",
"style",
"bootstrapping",
"via",
"{",
"@",
"link",
"javax",
"persistence",
"persistence",
"}",
"(",
"i",
"e",
"{",
"@",
"link",
"local",
"entity",
"manager",
"factory",
"bean",
"}",
")",
",",
"the",
"parameter",
"-",
"less",
"{",
"@",
"link",
"#",
"get",
"jpa",
"property",
"map",
"(",
")",
"}",
"variant",
"will",
"be",
"called",
"directly"
] |
[
"default",
"map",
"<",
"string",
",",
"?",
">",
"get",
"jpa",
"property",
"map",
"(",
"persistence",
"unit",
"info",
"pui",
")",
"{",
"return",
"get",
"jpa",
"property",
"map",
"(",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"name",
"'"
] |
[
"public",
"void",
"name",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"name",
"}"
] |
[
"setter",
"so",
"that",
"log",
"4j",
"can",
"configure",
"it",
"from",
"the",
"configuration",
"(",
"log",
"4j",
"properties",
")"
] |
[
"public",
"void",
"set",
"total",
"log",
"file",
"size",
"(",
"long",
"log",
"size",
")",
"{",
"max",
"events",
"=",
"(",
"int",
")",
"(",
"log",
"size",
"/",
"event",
"size",
")",
";",
"}"
] |
[
"return",
"the",
"configured",
"web",
"socket",
"client"
] |
[
"public",
"web",
"socket",
"client",
"get",
"web",
"socket",
"client",
"(",
")",
"{",
"return",
"this",
"web",
"socket",
"client",
";",
"}"
] |
[
"transcodes",
"the",
"given",
"resource",
"to",
"the",
"new",
"resource",
"type",
"and",
"returns",
"the",
"new",
"resource"
] |
[
"resource",
"<",
"r",
">",
"transcode",
"(",
"@",
"non",
"null",
"resource",
"<",
"z",
">",
"to",
"transcode",
",",
"@",
"non",
"null",
"options",
"options",
")",
";"
] |
[
"get",
"big",
"decimal"
] |
[
"public",
"big",
"decimal",
"get",
"big",
"decimal",
"(",
")",
"{",
"return",
"big",
"decimal",
";",
"}"
] |
[
"returns",
"the",
"dynamic",
"runtime",
"libraries"
] |
[
"public",
"nested",
"set",
"<",
"artifact",
">",
"get",
"dynamic",
"runtime",
"link",
"inputs",
"(",
"feature",
"configuration",
"feature",
"configuration",
")",
"throws",
"eval",
"exception",
"{",
"if",
"(",
"should",
"statically",
"link",
"cpp",
"runtimes",
"(",
"feature",
"configuration",
")",
")",
"{",
"if",
"(",
"dynamic",
"runtime",
"link",
"inputs",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"eval",
"exception",
"(",
"\"",
"toolchain",
"supports",
"embedded",
"runtimes",
",",
"but",
"didn",
"'",
"t",
"provide",
"dynamic",
"runtime",
"lib",
"\"",
"+",
"\"",
"attribute",
"\"",
")",
";",
"}",
"return",
"dynamic",
"runtime",
"link",
"inputs",
";",
"}",
"else",
"{",
"return",
"nested",
"set",
"builder",
"empty",
"set",
"(",
"order",
"stable",
"order",
")",
";",
"}",
"}"
] |
[
"the",
"layout",
"id",
"for",
"the",
"normal",
"data"
] |
[
"protected",
"int",
"get",
"normal",
"layout",
"res",
"id",
"(",
")",
"{",
"return",
"item",
"grid",
"cell",
"binder",
"layout",
";",
"}"
] |
[
"number",
"of",
"successful",
"shards"
] |
[
"public",
"int",
"successful",
"shards",
"(",
")",
"{",
"return",
"successful",
"shards",
";",
"}"
] |
[
"build",
"response",
"response",
"entity"
] |
[
"response",
"entity",
"<",
"string",
">",
"build",
"(",
"authentication",
"result",
"result",
",",
"http",
"servlet",
"request",
"request",
")",
"throws",
"exception",
";"
] |
[
"update",
"the",
"property",
"if",
"absent"
] |
[
"public",
"static",
"<",
"t",
">",
"void",
"update",
"property",
"if",
"absent",
"(",
"supplier",
"<",
"t",
">",
"getter",
"method",
",",
"consumer",
"<",
"t",
">",
"setter",
"method",
",",
"t",
"new",
"value",
")",
"{",
"if",
"(",
"new",
"value",
"!",
"=",
"null",
"&",
"&",
"getter",
"method",
"get",
"(",
")",
"=",
"=",
"null",
")",
"{",
"setter",
"method",
"accept",
"(",
"new",
"value",
")",
";",
"}",
"}"
] |
[
"allows",
"the",
"execution",
"of",
"flick",
"gestures",
"starting",
"in",
"a",
"location",
"'",
"s",
"element"
] |
[
"void",
"flick",
"(",
"coordinates",
"where",
",",
"int",
"x",
"offset",
",",
"int",
"y",
"offset",
",",
"int",
"speed",
")",
";"
] |
[
"for",
"use",
"in",
"tests"
] |
[
"public",
"static",
"container",
"node",
"parse",
"(",
"string",
"json",
")",
"throws",
"i",
"o",
"exception",
"{",
"json",
"node",
"json",
"node",
"=",
"reader",
"read",
"tree",
"(",
"json",
")",
";",
"if",
"(",
"!",
"(",
"json",
"node",
"instanceof",
"container",
"node",
")",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"wrong",
"json",
"data",
":",
"\"",
"+",
"json",
")",
";",
"}",
"return",
"(",
"container",
"node",
")",
"json",
"node",
";",
"}"
] |
[
"increments",
"the",
"missing",
"field",
"count",
"records",
"with",
"missing",
"fields",
"are",
"still",
"processed"
] |
[
"public",
"void",
"report",
"missing",
"field",
"(",
")",
"{",
"total",
"record",
"stats",
"increment",
"missing",
"field",
"count",
"(",
"1",
")",
";",
"incremental",
"record",
"stats",
"increment",
"missing",
"field",
"count",
"(",
"1",
")",
";",
"}"
] |
[
"clean",
"the",
"total",
"time"
] |
[
"public",
"void",
"reset",
"total",
"time",
"(",
")",
"{",
"if",
"(",
"is",
"total",
"time",
"expired",
"(",
")",
")",
"{",
"total",
"time",
"set",
"(",
"0l",
")",
";",
"last",
"reset",
"time",
"=",
"system",
"current",
"time",
"millis",
"(",
")",
";",
"}",
"}"
] |
[
"get",
"resources",
"using",
"the",
"label",
"color"
] |
[
"public",
"static",
"set",
"<",
"string",
">",
"get",
"text",
"resources",
"(",
")",
"{",
"return",
"collections",
"unmodifiable",
"set",
"(",
"sets",
"new",
"hash",
"set",
"(",
"\"",
"button",
"foreground",
"\"",
",",
"\"",
"button",
"mt",
"foreground",
"\"",
",",
"\"",
"check",
"box",
"menu",
"item",
"accelerator",
"foreground",
"\"",
",",
"\"",
"check",
"box",
"menu",
"item",
"accelerator",
"selection",
"foreground",
"\"",
",",
"\"",
"completion",
"popup",
"grayed",
"foreground",
"\"",
",",
"/",
"/",
"deprecated",
"\"",
"completion",
"popup",
"gray",
"foreground",
"\"",
",",
"/",
"/",
"deprcated",
"\"",
"completion",
"popup",
"info",
"foreground",
"\"",
",",
"\"",
"completion",
"popup",
"selection",
"inactive",
"foreground",
"\"",
",",
"/",
"/",
"deprecated",
"\"",
"completion",
"popup",
"selection",
"inactive",
"info",
"foreground",
"\"",
",",
"\"",
"component",
"info",
"foreground",
"\"",
",",
"\"",
"component",
"gray",
"foreground",
"\"",
",",
"/",
"/",
"deprecated",
"\"",
"control",
"text",
"\"",
",",
"\"",
"debugger",
"variables",
"collecting",
"data",
"foreground",
"\"",
",",
"\"",
"debugger",
"variables",
"evaluating",
"expression",
"foreground",
"\"",
",",
"\"",
"editor",
"shortcut",
"foreground",
"\"",
",",
"\"",
"git",
"log",
"ref",
"other",
"\"",
",",
"/",
"/",
"deprecated",
"\"",
"git",
"log",
"ref",
"tag",
"\"",
",",
"/",
"/",
"deprecated",
"\"",
"github",
"list",
"tall",
"row",
"secondary",
"foreground",
"\"",
",",
"\"",
"gutter",
"tooltip",
"info",
"foreground",
"\"",
",",
"\"",
"help",
"tooltip",
"info",
"foreground",
"\"",
",",
"\"",
"help",
"tooltip",
"shortcut",
"foreground",
"\"",
",",
"\"",
"help",
"tooltip",
"shortcut",
"text",
"color",
"\"",
",",
"/",
"/",
"deprecated",
"\"",
"hg",
"log",
"ref",
"local",
"tag",
"\"",
",",
"/",
"/",
"deprecated",
"\"",
"hg",
"log",
"ref",
"mq",
"tag",
"\"",
",",
"/",
"/",
"deprecated",
"\"",
"hg",
"log",
"ref",
"tag",
"\"",
",",
"/",
"/",
"deprecated",
"\"",
"inactive",
"caption",
"text",
"\"",
",",
"/",
"/",
"deprecated",
"\"",
"info",
"text",
"\"",
",",
"/",
"/",
"deprecated",
"\"",
"internal",
"frame",
"inactive",
"title",
"foreground",
"\"",
",",
"/",
"/",
"deprecated",
"\"",
"label",
"gray",
"foreground",
"\"",
",",
"/",
"/",
"deprecated",
"\"",
"label",
"info",
"foreground",
"\"",
",",
"\"",
"label",
"text",
"foreground",
"\"",
",",
"/",
"/",
"deprecated",
"\"",
"link",
"secondary",
"foreground",
"\"",
",",
"\"",
"material",
"primary",
"color",
"\"",
",",
"\"",
"material",
"tag",
"color",
"\"",
",",
"\"",
"menu",
"accelerator",
"foreground",
"\"",
",",
"\"",
"menu",
"item",
"accelerator",
"foreground",
"\"",
",",
"\"",
"parameter",
"info",
"context",
"help",
"foreground",
"\"",
",",
"/",
"/",
"deprecated",
"\"",
"parameter",
"info",
"info",
"foreground",
"\"",
",",
"\"",
"radio",
"button",
"menu",
"item",
"accelerator",
"foreground",
"\"",
",",
"\"",
"radio",
"button",
"menu",
"item",
"accelerator",
"selection",
"foreground",
"\"",
",",
"\"",
"search",
"everywhere",
"shortcut",
"foreground",
"\"",
",",
"/",
"/",
"deprecated",
"\"",
"search",
"everywhere",
"list",
"separator",
"foreground",
"\"",
",",
"\"",
"search",
"results",
"ordinal",
"file",
"foreground",
"\"",
",",
"\"",
"table",
"light",
"selection",
"inactive",
"foreground",
"\"",
",",
"\"",
"text",
"\"",
",",
"\"",
"text",
"inactive",
"text",
"\"",
",",
"\"",
"text",
"text",
"\"",
",",
"\"",
"title",
"pane",
"info",
"foreground",
"\"",
",",
"\"",
"tool",
"bar",
"border",
"handle",
"color",
"\"",
",",
"\"",
"tool",
"bar",
"floating",
"foreground",
"\"",
",",
"\"",
"tool",
"tip",
"actions",
"gray",
"foreground",
"\"",
",",
"/",
"/",
"deprecated",
"\"",
"tool",
"tip",
"actions",
"info",
"foreground",
"\"",
",",
"\"",
"tool",
"tip",
"info",
"foreground",
"\"",
",",
"\"",
"tool",
"tip",
"shortcut",
"foreground",
"\"",
",",
"\"",
"tooltips",
"actions",
"keymap",
"text",
"color",
"\"",
",",
"/",
"/",
"deprecated",
"\"",
"tree",
"foreground",
"\"",
",",
"\"",
"u",
"i",
"designer",
"label",
"foreground",
"\"",
",",
"\"",
"u",
"i",
"designer",
"stroke",
"accelerator",
"foreground",
"\"",
",",
"\"",
"u",
"i",
"designer",
"motion",
"secondary",
"panel",
"header",
"foreground",
"\"",
",",
"\"",
"u",
"i",
"designer",
"motion",
"constraint",
"set",
"text",
"foreground",
"\"",
",",
"\"",
"u",
"i",
"designer",
"motion",
"our",
"c",
"s",
"text",
"color",
"foreground",
"\"",
",",
"\"",
"u",
"i",
"designer",
"motion",
"cs",
"focus",
"text",
"info",
"foreground",
"\"",
",",
"\"",
"version",
"control",
"git",
"log",
"other",
"icon",
"color",
"\"",
",",
"\"",
"version",
"control",
"git",
"log",
"tag",
"icon",
"color",
"\"",
",",
"\"",
"version",
"control",
"hg",
"log",
"local",
"tag",
"icon",
"color",
"\"",
",",
"\"",
"version",
"control",
"hg",
"log",
"mq",
"tag",
"icon",
"color",
"\"",
",",
"\"",
"version",
"control",
"hg",
"log",
"tag",
"icon",
"color",
"\"",
",",
"\"",
"version",
"control",
"hg",
"log",
"tip",
"icon",
"color",
"\"",
",",
"\"",
"version",
"control",
"log",
"commit",
"unmatched",
"foreground",
"\"",
")",
")",
";",
"}"
] |
[
"sets",
"the",
"default",
"stereo",
"mode",
"if",
"the",
"played",
"video",
"doesn",
"'",
"t",
"contain",
"a",
"stereo",
"mode",
"the",
"default",
"one",
"is",
"used"
] |
[
"public",
"void",
"set",
"default",
"stereo",
"mode",
"(",
"@",
"c",
"stereo",
"mode",
"int",
"stereo",
"mode",
")",
"{",
"default",
"stereo",
"mode",
"=",
"stereo",
"mode",
";",
"}"
] |
[
"build",
"ct",
"class",
"object"
] |
[
"public",
"ct",
"class",
"build",
"(",
"class",
"loader",
"class",
"loader",
")",
"throws",
"not",
"found",
"exception",
",",
"cannot",
"compile",
"exception",
"{",
"class",
"pool",
"pool",
"=",
"new",
"class",
"pool",
"(",
"true",
")",
";",
"pool",
"append",
"class",
"path",
"(",
"new",
"loader",
"class",
"path",
"(",
"class",
"loader",
")",
")",
";",
"/",
"/",
"create",
"class",
"ct",
"class",
"ct",
"class",
"=",
"pool",
"make",
"class",
"(",
"class",
"name",
",",
"pool",
"get",
"(",
"super",
"class",
"name",
")",
")",
";",
"/",
"/",
"add",
"imported",
"packages",
"imports",
"stream",
"(",
")",
"for",
"each",
"(",
"pool",
":",
":",
"import",
"package",
")",
";",
"/",
"/",
"add",
"implemented",
"interfaces",
"for",
"(",
"string",
"iface",
":",
"ifaces",
")",
"{",
"ct",
"class",
"add",
"interface",
"(",
"pool",
"get",
"(",
"iface",
")",
")",
";",
"}",
"/",
"/",
"add",
"constructors",
"for",
"(",
"string",
"constructor",
":",
"constructors",
")",
"{",
"ct",
"class",
"add",
"constructor",
"(",
"ct",
"new",
"constructor",
"make",
"(",
"constructor",
",",
"ct",
"class",
")",
")",
";",
"}",
"/",
"/",
"add",
"fields",
"for",
"(",
"string",
"field",
":",
"fields",
")",
"{",
"ct",
"class",
"add",
"field",
"(",
"ct",
"field",
"make",
"(",
"field",
",",
"ct",
"class",
")",
")",
";",
"}",
"/",
"/",
"add",
"methods",
"for",
"(",
"string",
"method",
":",
"methods",
")",
"{",
"ct",
"class",
"add",
"method",
"(",
"ct",
"new",
"method",
"make",
"(",
"method",
",",
"ct",
"class",
")",
")",
";",
"}",
"return",
"ct",
"class",
";",
"}"
] |
[
"return",
"the",
"column",
"value",
"(",
"can",
"be",
"{",
"@",
"code",
"null",
"}",
")"
] |
[
"public",
"object",
"get",
"value",
"(",
")",
"{",
"return",
"this",
"value",
";",
"}"
] |
[
"used",
"from",
"{",
"@",
"code",
"polling",
"jelly",
"}",
"to",
"write",
"annotated",
"polling",
"log",
"to",
"the",
"given",
"output"
] |
[
"public",
"void",
"write",
"polling",
"log",
"to",
"(",
"long",
"offset",
",",
"x",
"m",
"l",
"output",
"out",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"/",
"todo",
":",
"resurrect",
"compressed",
"log",
"file",
"support",
"get",
"polling",
"log",
"text",
"(",
")",
"write",
"html",
"to",
"(",
"offset",
",",
"out",
"as",
"writer",
"(",
")",
")",
";",
"}"
] |
[
"query",
"configuration",
"information",
"based",
"on",
"group"
] |
[
"page",
"<",
"config",
"info",
">",
"find",
"config",
"info",
"by",
"group",
"(",
"final",
"int",
"page",
"no",
",",
"final",
"int",
"page",
"size",
",",
"final",
"string",
"group",
",",
"final",
"string",
"tenant",
")",
";"
] |
[
"creates",
"and",
"returns",
"the",
"kv",
"state",
"service"
] |
[
"public",
"static",
"kv",
"state",
"service",
"from",
"configuration",
"(",
"task",
"manager",
"services",
"configuration",
"task",
"manager",
"services",
"configuration",
")",
"{",
"kv",
"state",
"registry",
"kv",
"state",
"registry",
"=",
"new",
"kv",
"state",
"registry",
"(",
")",
";",
"queryable",
"state",
"configuration",
"qs",
"config",
"=",
"task",
"manager",
"services",
"configuration",
"get",
"queryable",
"state",
"config",
"(",
")",
";",
"kv",
"state",
"client",
"proxy",
"kv",
"client",
"proxy",
"=",
"null",
";",
"kv",
"state",
"server",
"kv",
"state",
"server",
"=",
"null",
";",
"if",
"(",
"qs",
"config",
"!",
"=",
"null",
")",
"{",
"int",
"num",
"proxy",
"server",
"network",
"threads",
"=",
"qs",
"config",
"num",
"proxy",
"server",
"threads",
"(",
")",
"=",
"=",
"0",
"?",
"task",
"manager",
"services",
"configuration",
"get",
"number",
"of",
"slots",
"(",
")",
":",
"qs",
"config",
"num",
"proxy",
"server",
"threads",
"(",
")",
";",
"int",
"num",
"proxy",
"server",
"query",
"threads",
"=",
"qs",
"config",
"num",
"proxy",
"query",
"threads",
"(",
")",
"=",
"=",
"0",
"?",
"task",
"manager",
"services",
"configuration",
"get",
"number",
"of",
"slots",
"(",
")",
":",
"qs",
"config",
"num",
"proxy",
"query",
"threads",
"(",
")",
";",
"kv",
"client",
"proxy",
"=",
"queryable",
"state",
"utils",
"create",
"kv",
"state",
"client",
"proxy",
"(",
"task",
"manager",
"services",
"configuration",
"get",
"external",
"address",
"(",
")",
",",
"qs",
"config",
"get",
"proxy",
"port",
"range",
"(",
")",
",",
"num",
"proxy",
"server",
"network",
"threads",
",",
"num",
"proxy",
"server",
"query",
"threads",
",",
"new",
"disabled",
"kv",
"state",
"request",
"stats",
"(",
")",
")",
";",
"int",
"num",
"state",
"server",
"network",
"threads",
"=",
"qs",
"config",
"num",
"state",
"server",
"threads",
"(",
")",
"=",
"=",
"0",
"?",
"task",
"manager",
"services",
"configuration",
"get",
"number",
"of",
"slots",
"(",
")",
":",
"qs",
"config",
"num",
"state",
"server",
"threads",
"(",
")",
";",
"int",
"num",
"state",
"server",
"query",
"threads",
"=",
"qs",
"config",
"num",
"state",
"query",
"threads",
"(",
")",
"=",
"=",
"0",
"?",
"task",
"manager",
"services",
"configuration",
"get",
"number",
"of",
"slots",
"(",
")",
":",
"qs",
"config",
"num",
"state",
"query",
"threads",
"(",
")",
";",
"kv",
"state",
"server",
"=",
"queryable",
"state",
"utils",
"create",
"kv",
"state",
"server",
"(",
"task",
"manager",
"services",
"configuration",
"get",
"external",
"address",
"(",
")",
",",
"qs",
"config",
"get",
"state",
"server",
"port",
"range",
"(",
")",
",",
"num",
"state",
"server",
"network",
"threads",
",",
"num",
"state",
"server",
"query",
"threads",
",",
"kv",
"state",
"registry",
",",
"new",
"disabled",
"kv",
"state",
"request",
"stats",
"(",
")",
")",
";",
"}",
"return",
"new",
"kv",
"state",
"service",
"(",
"kv",
"state",
"registry",
",",
"kv",
"state",
"server",
",",
"kv",
"client",
"proxy",
")",
";",
"}"
] |
[
"called",
"any",
"time",
"the",
"mouse",
"is",
"moved",
"when",
"a",
"button",
"is",
"not",
"down",
"this",
"event",
"only",
"occurs",
"on",
"the",
"desktop",
"when",
"true",
"is",
"returned",
",",
"the",
"event",
"is",
"{",
"@",
"link",
"event",
"#",
"handle",
"(",
")",
"handled",
"}"
] |
[
"public",
"boolean",
"mouse",
"moved",
"(",
"input",
"event",
"event",
",",
"float",
"x",
",",
"float",
"y",
")",
"{",
"return",
"false",
";",
"}"
] |
[
"only",
"select",
"historic",
"variable",
"updates",
"associated",
"to",
"the",
"given",
"{",
"@",
"link",
"historic",
"task",
"instance",
"historic",
"task",
"instance",
"}"
] |
[
"historic",
"detail",
"query",
"task",
"id",
"(",
"string",
"task",
"id",
")",
";"
] |
[
"called",
"when",
"a",
"segment",
"of",
"a",
"build",
"is",
"started",
"that",
"is",
"to",
"be",
"enhanced",
"with",
"this",
"wrapper",
"this",
"method",
"must",
"be",
"overridden",
"when",
"this",
"wrapper",
"does",
"not",
"require",
"a",
"workspace",
"context",
",",
"and",
"will",
"not",
"be",
"called",
"when",
"such",
"a",
"context",
"is",
"required"
] |
[
"public",
"void",
"set",
"up",
"(",
"context",
"context",
",",
"run",
"<",
"?",
",",
"?",
">",
"build",
",",
"task",
"listener",
"listener",
",",
"env",
"vars",
"initial",
"environment",
")",
"throws",
"i",
"o",
"exception",
",",
"interrupted",
"exception",
"{",
"/",
"/",
"if",
"this",
"wrapper",
"requires",
"a",
"workspace",
",",
"this",
"is",
"the",
"wrong",
"method",
"to",
"call",
"if",
"(",
"this",
"requires",
"workspace",
"(",
")",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"this",
"build",
"wrapper",
"requires",
"a",
"workspace",
"context",
",",
"but",
"none",
"was",
"provided",
"\"",
")",
";",
"}",
"/",
"/",
"otherwise",
",",
"this",
"method",
"must",
"have",
"an",
"implementation",
"throw",
"new",
"abstract",
"method",
"error",
"(",
"\"",
"when",
"a",
"build",
"wrapper",
"is",
"marked",
"as",
"not",
"requiring",
"a",
"workspace",
"context",
",",
"you",
"must",
"implement",
"the",
"overload",
"of",
"the",
"set",
"up",
"(",
")",
"method",
"that",
"does",
"not",
"take",
"a",
"workspace",
"or",
"launcher",
"\"",
")",
";",
"}"
] |
[
"gets",
"the",
"pseudo",
"disassembler",
"used",
"by",
"this",
"class",
"this",
"method",
"will",
"lazy",
"load",
"the",
"disassembler",
"to",
"prevent",
"wasting",
"of",
"resources",
"if",
"the",
"program",
"location",
"changes",
",",
"then",
"the",
"disassembler",
"will",
"be",
"recreated"
] |
[
"private",
"pseudo",
"disassembler",
"get",
"pseudo",
"disassembler",
"(",
")",
"{",
"if",
"(",
"pseudo",
"disassembler",
"=",
"=",
"null",
")",
"{",
"pseudo",
"disassembler",
"=",
"new",
"pseudo",
"disassembler",
"(",
"current",
"program",
")",
";",
"}",
"return",
"pseudo",
"disassembler",
";",
"}"
] |
[
"test",
"if",
"a",
"i",
"node",
"file",
"under",
"a",
"replication",
"ec",
"policy",
"directory",
"can",
"be",
"saved",
"by",
"f",
"s",
"image",
"serialization",
"and",
"loaded",
"by",
"f",
"s",
"image",
"format",
"#",
"loader"
] |
[
"public",
"void",
"test",
"save",
"and",
"load",
"file",
"under",
"replication",
"policy",
"dir",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"configuration",
"conf",
"=",
"new",
"configuration",
"(",
")",
";",
"mini",
"d",
"f",
"s",
"cluster",
"cluster",
"=",
"null",
";",
"try",
"{",
"cluster",
"=",
"new",
"mini",
"d",
"f",
"s",
"cluster",
"builder",
"(",
"conf",
")",
"build",
"(",
")",
";",
"cluster",
"wait",
"active",
"(",
")",
";",
"f",
"s",
"namesystem",
"fsn",
"=",
"cluster",
"get",
"namesystem",
"(",
")",
";",
"distributed",
"file",
"system",
"fs",
"=",
"cluster",
"get",
"file",
"system",
"(",
")",
";",
"d",
"f",
"s",
"test",
"util",
"enable",
"all",
"e",
"c",
"policies",
"(",
"fs",
")",
";",
"erasure",
"coding",
"policy",
"replica",
"policy",
"=",
"system",
"erasure",
"coding",
"policies",
"get",
"replication",
"policy",
"(",
")",
";",
"erasure",
"coding",
"policy",
"default",
"ec",
"policy",
"=",
"striped",
"file",
"test",
"util",
"get",
"default",
"e",
"c",
"policy",
"(",
")",
";",
"final",
"path",
"ec",
"dir",
"=",
"new",
"path",
"(",
"\"",
"/",
"ec",
"\"",
")",
";",
"final",
"path",
"replica",
"dir",
"=",
"new",
"path",
"(",
"ec",
"dir",
",",
"\"",
"replica",
"\"",
")",
";",
"final",
"path",
"replica",
"file",
"1",
"=",
"new",
"path",
"(",
"replica",
"dir",
",",
"\"",
"f",
"1",
"\"",
")",
";",
"final",
"path",
"replica",
"file",
"2",
"=",
"new",
"path",
"(",
"replica",
"dir",
",",
"\"",
"f",
"2",
"\"",
")",
";",
"/",
"/",
"create",
"root",
"directory",
"fs",
"mkdir",
"(",
"ec",
"dir",
",",
"null",
")",
";",
"fs",
"set",
"erasure",
"coding",
"policy",
"(",
"ec",
"dir",
",",
"default",
"ec",
"policy",
"get",
"name",
"(",
")",
")",
";",
"/",
"/",
"create",
"directory",
",",
"and",
"set",
"replication",
"policy",
"fs",
"mkdir",
"(",
"replica",
"dir",
",",
"null",
")",
";",
"fs",
"set",
"erasure",
"coding",
"policy",
"(",
"replica",
"dir",
",",
"replica",
"policy",
"get",
"name",
"(",
")",
")",
";",
"/",
"/",
"create",
"an",
"empty",
"file",
"f",
"1",
"fs",
"create",
"(",
"replica",
"file",
"1",
")",
"close",
"(",
")",
";",
"/",
"/",
"create",
"an",
"under",
"-",
"construction",
"file",
"f",
"2",
"f",
"s",
"data",
"output",
"stream",
"out",
"=",
"fs",
"create",
"(",
"replica",
"file",
"2",
",",
"(",
"short",
")",
"2",
")",
";",
"out",
"write",
"bytes",
"(",
"\"",
"hello",
"\"",
")",
";",
"(",
"(",
"d",
"f",
"s",
"output",
"stream",
")",
"out",
"get",
"wrapped",
"stream",
"(",
")",
")",
"hsync",
"(",
"enum",
"set",
"of",
"(",
"sync",
"flag",
"update",
"length",
")",
")",
";",
"/",
"/",
"checkpoint",
"fs",
"set",
"safe",
"mode",
"(",
"safe",
"mode",
"action",
"safemode",
"enter",
")",
";",
"fs",
"save",
"namespace",
"(",
")",
";",
"fs",
"set",
"safe",
"mode",
"(",
"safe",
"mode",
"action",
"safemode",
"leave",
")",
";",
"cluster",
"restart",
"name",
"node",
"(",
")",
";",
"cluster",
"wait",
"active",
"(",
")",
";",
"fs",
"=",
"cluster",
"get",
"file",
"system",
"(",
")",
";",
"assert",
"true",
"(",
"fs",
"get",
"file",
"status",
"(",
"ec",
"dir",
")",
"is",
"directory",
"(",
")",
")",
";",
"assert",
"true",
"(",
"fs",
"get",
"file",
"status",
"(",
"replica",
"dir",
")",
"is",
"directory",
"(",
")",
")",
";",
"assert",
"true",
"(",
"fs",
"exists",
"(",
"replica",
"file",
"1",
")",
")",
";",
"assert",
"true",
"(",
"fs",
"exists",
"(",
"replica",
"file",
"2",
")",
")",
";",
"/",
"/",
"check",
"directories",
"assert",
"equals",
"(",
"\"",
"directory",
"should",
"have",
"default",
"ec",
"policy",
"\"",
",",
"default",
"ec",
"policy",
",",
"fs",
"get",
"erasure",
"coding",
"policy",
"(",
"ec",
"dir",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"directory",
"should",
"hide",
"replication",
"ec",
"policy",
"\"",
",",
"null",
",",
"fs",
"get",
"erasure",
"coding",
"policy",
"(",
"replica",
"dir",
")",
")",
";",
"/",
"/",
"check",
"file",
"1",
"assert",
"equals",
"(",
"\"",
"file",
"should",
"not",
"have",
"ec",
"policy",
"\"",
",",
"null",
",",
"fs",
"get",
"erasure",
"coding",
"policy",
"(",
"replica",
"file",
"1",
")",
")",
";",
"/",
"/",
"check",
"internals",
"of",
"file",
"2",
"i",
"node",
"file",
"file",
"2",
"node",
"=",
"fsn",
"dir",
"get",
"i",
"node",
"4",
"write",
"(",
"replica",
"file",
"2",
"to",
"string",
"(",
")",
")",
"as",
"file",
"(",
")",
";",
"assert",
"equals",
"(",
"\"",
"hello",
"\"",
"length",
"(",
")",
",",
"file",
"2",
"node",
"compute",
"file",
"size",
"(",
")",
")",
";",
"assert",
"true",
"(",
"file",
"2",
"node",
"is",
"under",
"construction",
"(",
")",
")",
";",
"block",
"info",
"[",
"]",
"blks",
"=",
"file",
"2",
"node",
"get",
"blocks",
"(",
")",
";",
"assert",
"equals",
"(",
"1",
",",
"blks",
"length",
")",
";",
"assert",
"equals",
"(",
"block",
"u",
"c",
"state",
"under",
"construction",
",",
"blks",
"[",
"0",
"]",
"get",
"block",
"u",
"c",
"state",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"file",
"should",
"return",
"expected",
"replication",
"factor",
"\"",
",",
"2",
",",
"blks",
"[",
"0",
"]",
"get",
"replication",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"file",
"should",
"not",
"have",
"ec",
"policy",
"\"",
",",
"null",
",",
"fs",
"get",
"erasure",
"coding",
"policy",
"(",
"replica",
"file",
"2",
")",
")",
";",
"/",
"/",
"check",
"lease",
"manager",
"lease",
"lease",
"=",
"fsn",
"lease",
"manager",
"get",
"lease",
"(",
"file",
"2",
"node",
")",
";",
"assert",
"assert",
"not",
"null",
"(",
"lease",
")",
";",
"}",
"finally",
"{",
"if",
"(",
"cluster",
"!",
"=",
"null",
")",
"{",
"cluster",
"shutdown",
"(",
")",
";",
"}",
"}",
"}"
] |
[
"append",
"the",
"usage",
"message",
"for",
"a",
"single",
"option",
"-",
"field",
"message",
"to",
"'",
"usage",
"'"
] |
[
"static",
"void",
"get",
"usage",
"html",
"(",
"option",
"definition",
"option",
"definition",
",",
"string",
"builder",
"usage",
",",
"escaper",
"escaper",
",",
"options",
"data",
"options",
"data",
",",
"boolean",
"include",
"tags",
")",
"{",
"string",
"plain",
"flag",
"name",
"=",
"option",
"definition",
"get",
"option",
"name",
"(",
")",
";",
"string",
"flag",
"name",
"=",
"get",
"flag",
"name",
"(",
"option",
"definition",
")",
";",
"string",
"value",
"description",
"=",
"option",
"definition",
"get",
"value",
"type",
"help",
"text",
"(",
")",
";",
"string",
"type",
"description",
"=",
"get",
"type",
"description",
"(",
"option",
"definition",
")",
";",
"/",
"/",
"string",
"format",
"is",
"a",
"lot",
"slower",
",",
"sometimes",
"up",
"to",
"1",
"0x",
"/",
"/",
"https",
":",
"/",
"/",
"stackoverflow",
"com",
"/",
"questions",
"/",
"925423",
"/",
"is",
"-",
"it",
"-",
"better",
"-",
"practice",
"-",
"to",
"-",
"use",
"-",
"string",
"-",
"format",
"-",
"over",
"-",
"string",
"-",
"concatenation",
"-",
"in",
"-",
"java",
"/",
"/",
"/",
"/",
"considering",
"that",
"this",
"runs",
"for",
"every",
"flag",
"in",
"the",
"cli",
"reference",
",",
"it",
"'",
"s",
"better",
"to",
"use",
"regular",
"/",
"/",
"appends",
"here",
"usage",
"/",
"/",
"add",
"the",
"id",
"of",
"the",
"flag",
"to",
"point",
"anchor",
"hrefs",
"to",
"it",
"append",
"(",
"\"",
"<",
"dt",
"id",
"=",
"\\",
"\"",
"flag",
"-",
"-",
"\"",
")",
"append",
"(",
"plain",
"flag",
"name",
")",
"append",
"(",
"\"",
"\\",
"\"",
">",
"\"",
")",
"/",
"/",
"add",
"the",
"href",
"to",
"the",
"id",
"hash",
"append",
"(",
"\"",
"<",
"code",
">",
"<",
"a",
"href",
"=",
"\\",
"\"",
"#",
"flag",
"-",
"-",
"\"",
")",
"append",
"(",
"plain",
"flag",
"name",
")",
"append",
"(",
"\"",
"\\",
"\"",
">",
"\"",
")",
"append",
"(",
"\"",
"-",
"-",
"\"",
")",
"append",
"(",
"flag",
"name",
")",
"append",
"(",
"\"",
"<",
"/",
"a",
">",
"\"",
")",
";",
"if",
"(",
"option",
"definition",
"uses",
"boolean",
"value",
"syntax",
"(",
")",
"|",
"|",
"option",
"definition",
"is",
"void",
"field",
"(",
")",
")",
"{",
"/",
"/",
"nothing",
"for",
"boolean",
",",
"tristate",
",",
"boolean",
"or",
"enum",
",",
"or",
"void",
"options",
"}",
"else",
"if",
"(",
"!",
"value",
"description",
"is",
"empty",
"(",
")",
")",
"{",
"usage",
"append",
"(",
"\"",
"=",
"\"",
")",
"append",
"(",
"escaper",
"escape",
"(",
"value",
"description",
")",
")",
";",
"}",
"else",
"if",
"(",
"!",
"type",
"description",
"is",
"empty",
"(",
")",
")",
"{",
"/",
"/",
"generic",
"fallback",
",",
"which",
"isn",
"'",
"t",
"very",
"good",
"usage",
"append",
"(",
"\"",
"=",
"&",
"lt",
";",
"\"",
")",
"append",
"(",
"escaper",
"escape",
"(",
"type",
"description",
")",
")",
"append",
"(",
"\"",
"&",
"gt",
"\"",
")",
";",
"}",
"usage",
"append",
"(",
"\"",
"<",
"/",
"code",
">",
"\"",
")",
";",
"if",
"(",
"option",
"definition",
"get",
"abbreviation",
"(",
")",
"!",
"=",
"'",
"\\",
"0",
"'",
")",
"{",
"usage",
"append",
"(",
"\"",
"[",
"<",
"code",
">",
"-",
"\"",
")",
"append",
"(",
"option",
"definition",
"get",
"abbreviation",
"(",
")",
")",
"append",
"(",
"\"",
"<",
"/",
"code",
">",
"]",
"\"",
")",
";",
"}",
"if",
"(",
"option",
"definition",
"allows",
"multiple",
"(",
")",
")",
"{",
"/",
"/",
"allow",
"-",
"multiple",
"options",
"can",
"'",
"t",
"have",
"a",
"default",
"value",
"usage",
"append",
"(",
"\"",
"multiple",
"uses",
"are",
"accumulated",
"\"",
")",
";",
"}",
"else",
"{",
"/",
"/",
"don",
"'",
"t",
"call",
"the",
"annotation",
"directly",
"(",
"we",
"must",
"allow",
"overrides",
"to",
"certain",
"defaults",
")",
"string",
"default",
"value",
"string",
"=",
"option",
"definition",
"get",
"unparsed",
"default",
"value",
"(",
")",
";",
"if",
"(",
"option",
"definition",
"is",
"void",
"field",
"(",
")",
")",
"{",
"/",
"/",
"void",
"options",
"don",
"'",
"t",
"have",
"a",
"default",
"}",
"else",
"if",
"(",
"option",
"definition",
"is",
"special",
"null",
"default",
"(",
")",
")",
"{",
"usage",
"append",
"(",
"\"",
"default",
":",
"see",
"description",
"\"",
")",
";",
"}",
"else",
"{",
"usage",
"append",
"(",
"\"",
"default",
":",
"\\",
"\"",
"\"",
")",
"append",
"(",
"escaper",
"escape",
"(",
"default",
"value",
"string",
")",
")",
"append",
"(",
"\"",
"\\",
"\"",
"\"",
")",
";",
"}",
"}",
"usage",
"append",
"(",
"\"",
"<",
"/",
"dt",
">",
"\\",
"n",
"\"",
")",
";",
"usage",
"append",
"(",
"\"",
"<",
"dd",
">",
"\\",
"n",
"\"",
")",
";",
"if",
"(",
"!",
"option",
"definition",
"get",
"help",
"text",
"(",
")",
"is",
"empty",
"(",
")",
")",
"{",
"usage",
"append",
"(",
"escaper",
"escape",
"(",
"option",
"definition",
"get",
"help",
"text",
"(",
")",
")",
")",
";",
"usage",
"append",
"(",
"'",
"\\",
"n",
"'",
")",
";",
"}",
"if",
"(",
"!",
"options",
"data",
"get",
"evaluated",
"expansion",
"(",
"option",
"definition",
")",
"is",
"empty",
"(",
")",
")",
"{",
"/",
"/",
"if",
"this",
"is",
"an",
"expansion",
"option",
",",
"list",
"the",
"expansion",
"if",
"known",
",",
"or",
"at",
"least",
"specify",
"that",
"we",
"/",
"/",
"don",
"'",
"t",
"know",
"usage",
"append",
"(",
"\"",
"<",
"br",
"/",
">",
"\\",
"n",
"\"",
")",
";",
"immutable",
"list",
"<",
"string",
">",
"expansion",
"=",
"get",
"expansion",
"if",
"known",
"(",
"option",
"definition",
",",
"options",
"data",
")",
";",
"string",
"builder",
"expands",
"msg",
";",
"if",
"(",
"expansion",
"=",
"=",
"null",
")",
"{",
"expands",
"msg",
"=",
"new",
"string",
"builder",
"(",
"\"",
"expands",
"to",
"unknown",
"options",
"<",
"br",
"/",
">",
"\\",
"n",
"\"",
")",
";",
"}",
"else",
"{",
"preconditions",
"check",
"argument",
"(",
"!",
"expansion",
"is",
"empty",
"(",
")",
")",
";",
"expands",
"msg",
"=",
"new",
"string",
"builder",
"(",
"\"",
"expands",
"to",
":",
"<",
"br",
"/",
">",
"\\",
"n",
"\"",
")",
";",
"for",
"(",
"string",
"exp",
":",
"expansion",
")",
"{",
"/",
"/",
"todo",
"(",
"jingwen",
")",
":",
"we",
"link",
"to",
"the",
"expanded",
"flags",
"here",
",",
"but",
"unfortunately",
"we",
"don",
"'",
"t",
"/",
"/",
"currently",
"guarantee",
"that",
"all",
"flags",
"are",
"only",
"printed",
"once",
"a",
"flag",
"in",
"an",
"option",
"base",
"that",
"/",
"/",
"is",
"included",
"by",
"2",
"different",
"commands",
",",
"but",
"not",
"inherited",
"through",
"a",
"parent",
"command",
",",
"will",
"/",
"/",
"be",
"printed",
"multiple",
"times",
"clicking",
"on",
"the",
"flag",
"will",
"bring",
"the",
"user",
"to",
"its",
"first",
"/",
"/",
"definition",
"expands",
"msg",
"append",
"(",
"\"",
"&",
"nbsp",
";",
"&",
"nbsp",
";",
"\"",
")",
"append",
"(",
"\"",
"<",
"code",
">",
"<",
"a",
"href",
"=",
"\\",
"\"",
"#",
"flag",
"\"",
")",
"/",
"/",
"link",
"to",
"the",
"'",
"#",
"flag",
"-",
"-",
"flag",
"name",
"'",
"hash",
"/",
"/",
"some",
"expansions",
"are",
"in",
"the",
"form",
"of",
"'",
"-",
"-",
"flag",
"name",
"=",
"value",
"'",
",",
"so",
"we",
"drop",
"everything",
"from",
"/",
"/",
"'",
"=",
"'",
"onwards",
"append",
"(",
"iterables",
"get",
"(",
"splitter",
"on",
"(",
"'",
"=",
"'",
")",
"split",
"(",
"escaper",
"escape",
"(",
"exp",
")",
")",
",",
"0",
")",
")",
"append",
"(",
"\"",
"\\",
"\"",
">",
"\"",
")",
"append",
"(",
"escaper",
"escape",
"(",
"exp",
")",
")",
"append",
"(",
"\"",
"<",
"/",
"a",
">",
"<",
"/",
"code",
">",
"<",
"br",
"/",
">",
"\\",
"n",
"\"",
")",
";",
"}",
"}",
"usage",
"append",
"(",
"expands",
"msg",
"to",
"string",
"(",
")",
")",
";",
"}",
"/",
"/",
"add",
"effect",
"tags",
",",
"if",
"not",
"unknown",
",",
"and",
"metadata",
"tags",
",",
"if",
"not",
"empty",
"if",
"(",
"include",
"tags",
")",
"{",
"stream",
"<",
"option",
"effect",
"tag",
">",
"effect",
"tag",
"stream",
"=",
"arrays",
"stream",
"(",
"option",
"definition",
"get",
"option",
"effect",
"tags",
"(",
")",
")",
"filter",
"(",
"options",
"usage",
":",
":",
"should",
"effect",
"tag",
"be",
"listed",
")",
";",
"stream",
"<",
"option",
"metadata",
"tag",
">",
"metadata",
"tag",
"stream",
"=",
"arrays",
"stream",
"(",
"option",
"definition",
"get",
"option",
"metadata",
"tags",
"(",
")",
")",
"filter",
"(",
"options",
"usage",
":",
":",
"should",
"metadata",
"tag",
"be",
"listed",
")",
";",
"string",
"tag",
"list",
"=",
"stream",
"concat",
"(",
"effect",
"tag",
"stream",
"map",
"(",
"tag",
"-",
">",
"string",
"format",
"(",
"\"",
"<",
"a",
"href",
"=",
"\\",
"\"",
"#",
"effect",
"tag",
"%",
"s",
"\\",
"\"",
">",
"<",
"code",
">",
"%",
"s",
"<",
"/",
"code",
">",
"<",
"/",
"a",
">",
"\"",
",",
"tag",
",",
"tag",
"name",
"(",
")",
"to",
"lower",
"case",
"(",
")",
")",
")",
",",
"metadata",
"tag",
"stream",
"map",
"(",
"tag",
"-",
">",
"string",
"format",
"(",
"\"",
"<",
"a",
"href",
"=",
"\\",
"\"",
"#",
"metadata",
"tag",
"%",
"s",
"\\",
"\"",
">",
"<",
"code",
">",
"%",
"s",
"<",
"/",
"code",
">",
"<",
"/",
"a",
">",
"\"",
",",
"tag",
",",
"tag",
"name",
"(",
")",
"to",
"lower",
"case",
"(",
")",
")",
")",
")",
"collect",
"(",
"collectors",
"joining",
"(",
"\"",
",",
"\"",
")",
")",
";",
"if",
"(",
"!",
"tag",
"list",
"is",
"empty",
"(",
")",
")",
"{",
"usage",
"append",
"(",
"\"",
"<",
"br",
">",
"tags",
":",
"\\",
"n",
"\"",
")",
"append",
"(",
"tag",
"list",
")",
";",
"}",
"}",
"usage",
"append",
"(",
"\"",
"<",
"/",
"dd",
">",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"postmultiplies",
"this",
"matrix",
"with",
"a",
"scale",
"matrix"
] |
[
"public",
"affine",
"2",
"scale",
"(",
"vector",
"2",
"scale",
")",
"{",
"return",
"scale",
"(",
"scale",
"x",
",",
"scale",
"y",
")",
";",
"}"
] |
[
"return",
"the",
"{",
"@",
"link",
"configuration",
"}",
"return",
"configuration",
"{",
"@",
"link",
"configuration",
"}"
] |
[
"public",
"configuration",
"get",
"configuration",
"(",
")",
"{",
"return",
"this",
"configuration",
";",
"}"
] |
[
"determine",
"if",
"the",
"current",
"{",
"@",
"code",
"resource",
"name",
"}",
"exists",
"at",
"the",
"{",
"@",
"code",
"resource",
"base",
"path",
"}",
"endpoint",
"with",
"a",
"version",
"greater",
"than",
"or",
"equal",
"to",
"the",
"expected",
"version",
"this",
"provides",
"the",
"base",
"-",
"level",
"check",
"for",
"any",
"resource",
"that",
"does",
"not",
"need",
"to",
"care",
"about",
"its",
"response",
"beyond",
"existence",
"(",
"and",
"likely",
"does",
"not",
"need",
"to",
"inspect",
"its",
"contents",
")",
"this",
"expects",
"responses",
"in",
"the",
"form",
"of",
":",
"<",
"code",
">",
"{",
"\"",
"resource",
"name",
"\"",
":",
"{",
"\"",
"version",
"\"",
":",
"6000002",
"}",
"}",
"<",
"code",
">"
] |
[
"protected",
"void",
"version",
"check",
"for",
"resource",
"(",
"final",
"rest",
"client",
"client",
",",
"final",
"action",
"listener",
"<",
"boolean",
">",
"listener",
",",
"final",
"logger",
"logger",
",",
"final",
"string",
"resource",
"base",
"path",
",",
"final",
"string",
"resource",
"name",
",",
"final",
"string",
"resource",
"type",
",",
"final",
"string",
"resource",
"owner",
"name",
",",
"final",
"string",
"resource",
"owner",
"type",
",",
"final",
"x",
"content",
"x",
"content",
",",
"final",
"int",
"minimum",
"version",
")",
"{",
"final",
"checked",
"function",
"<",
"response",
",",
"boolean",
",",
"i",
"o",
"exception",
">",
"response",
"checker",
"=",
"(",
"response",
")",
"-",
">",
"should",
"replace",
"resource",
"(",
"response",
",",
"x",
"content",
",",
"resource",
"name",
",",
"minimum",
"version",
")",
";",
"check",
"for",
"resource",
"(",
"client",
",",
"listener",
",",
"logger",
",",
"resource",
"base",
"path",
",",
"resource",
"name",
",",
"resource",
"type",
",",
"resource",
"owner",
"name",
",",
"resource",
"owner",
"type",
",",
"get",
"exists",
",",
"get",
"does",
"not",
"exist",
",",
"response",
"checker",
",",
"this",
":",
":",
"always",
"replace",
"resource",
")",
";",
"}"
] |
[
"this",
"method",
"deserializes",
"the",
"specified",
"json",
"into",
"an",
"object",
"of",
"the",
"specified",
"class",
"it",
"is",
"not",
"suitable",
"to",
"use",
"if",
"the",
"specified",
"class",
"is",
"a",
"generic",
"type",
"since",
"it",
"will",
"not",
"have",
"the",
"generic",
"type",
"information",
"because",
"of",
"the",
"type",
"erasure",
"feature",
"of",
"java",
"therefore",
",",
"this",
"method",
"should",
"not",
"be",
"used",
"if",
"the",
"desired",
"type",
"is",
"a",
"generic",
"type",
"note",
"that",
"this",
"method",
"works",
"fine",
"if",
"the",
"any",
"of",
"the",
"fields",
"of",
"the",
"specified",
"object",
"are",
"generics",
",",
"just",
"the",
"object",
"itself",
"should",
"not",
"be",
"a",
"generic",
"type",
"for",
"the",
"cases",
"when",
"the",
"object",
"is",
"of",
"generic",
"type",
",",
"invoke",
"{",
"@",
"link",
"#",
"from",
"json",
"(",
"string",
",",
"type",
")",
"}",
"if",
"you",
"have",
"the",
"json",
"in",
"a",
"{",
"@",
"link",
"reader",
"}",
"instead",
"of",
"a",
"string",
",",
"use",
"{",
"@",
"link",
"#",
"from",
"json",
"(",
"reader",
",",
"class",
")",
"}",
"instead"
] |
[
"public",
"<",
"t",
">",
"t",
"from",
"json",
"(",
"string",
"json",
",",
"class",
"<",
"t",
">",
"class",
"of",
"t",
")",
"throws",
"json",
"syntax",
"exception",
"{",
"object",
"object",
"=",
"from",
"json",
"(",
"json",
",",
"(",
"type",
")",
"class",
"of",
"t",
")",
";",
"return",
"primitives",
"wrap",
"(",
"class",
"of",
"t",
")",
"cast",
"(",
"object",
")",
";",
"}"
] |
[
"get",
"number",
"item"
] |
[
"public",
"big",
"decimal",
"get",
"number",
"item",
"(",
")",
"{",
"return",
"number",
"item",
";",
"}"
] |
[
"indicates",
"whether",
"the",
"given",
"header",
"name",
"is",
"a",
"valid",
"http2",
"pseudo",
"header"
] |
[
"public",
"static",
"boolean",
"is",
"pseudo",
"header",
"(",
"char",
"sequence",
"header",
")",
"{",
"return",
"pseudo",
"headers",
"contains",
"(",
"header",
")",
";",
"}"
] |
[
"returns",
"true",
"if",
"the",
"specified",
"node",
"is",
"this",
"node",
"or",
"an",
"ascendant",
"of",
"this",
"node"
] |
[
"public",
"boolean",
"is",
"ascendant",
"of",
"(",
"n",
"node",
")",
"{",
"if",
"(",
"node",
"=",
"=",
"null",
")",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"node",
"cannot",
"be",
"null",
"\"",
")",
";",
"node",
"current",
"=",
"node",
";",
"do",
"{",
"if",
"(",
"current",
"=",
"=",
"this",
")",
"return",
"true",
";",
"current",
"=",
"current",
"parent",
";",
"}",
"while",
"(",
"current",
"!",
"=",
"null",
")",
";",
"return",
"false",
";",
"}"
] |
[
"end",
"the",
"most",
"recent",
"annotation",
"subsequent",
"output",
"will",
"be",
"unannotated",
",",
"until",
"the",
"next",
"call",
"to",
"{",
"@",
"link",
"#",
"annotate",
"}"
] |
[
"public",
"void",
"end",
"annotation",
"(",
")",
";"
] |
[
"is",
"the",
"path",
"one",
"of",
"the",
"special",
"paths",
"owned",
"by",
"zookeeper"
] |
[
"boolean",
"is",
"special",
"path",
"(",
"string",
"path",
")",
"{",
"return",
"root",
"zookeeper",
"equals",
"(",
"path",
")",
"|",
"|",
"proc",
"zookeeper",
"equals",
"(",
"path",
")",
"|",
"|",
"quota",
"zookeeper",
"equals",
"(",
"path",
")",
"|",
"|",
"config",
"zookeeper",
"equals",
"(",
"path",
")",
";",
"}"
] |
[
"parses",
"the",
"\"",
"snapshots",
"\"",
"field",
"and",
"fills",
"maps",
"for",
"the",
"various",
"per",
"snapshot",
"properties",
"this",
"method",
"must",
"run",
"before",
"{",
"@",
"link",
"#",
"parse",
"indices",
"}",
"which",
"will",
"rely",
"on",
"the",
"maps",
"of",
"snapshot",
"properties",
"to",
"have",
"been",
"populated",
"already"
] |
[
"private",
"static",
"void",
"parse",
"snapshots",
"(",
"x",
"content",
"parser",
"parser",
",",
"map",
"<",
"string",
",",
"snapshot",
"id",
">",
"snapshots",
",",
"map",
"<",
"string",
",",
"snapshot",
"state",
">",
"snapshot",
"states",
",",
"map",
"<",
"string",
",",
"version",
">",
"snapshot",
"versions",
",",
"map",
"<",
"snapshot",
"id",
",",
"map",
"<",
"string",
",",
"string",
">",
">",
"index",
"meta",
"lookup",
")",
"throws",
"i",
"o",
"exception",
"{",
"x",
"content",
"parser",
"utils",
"ensure",
"expected",
"token",
"(",
"x",
"content",
"parser",
"token",
"start",
"array",
",",
"parser",
"next",
"token",
"(",
")",
",",
"parser",
")",
";",
"final",
"map",
"<",
"string",
",",
"string",
">",
"string",
"deduplicator",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"while",
"(",
"parser",
"next",
"token",
"(",
")",
"!",
"=",
"x",
"content",
"parser",
"token",
"end",
"array",
")",
"{",
"string",
"name",
"=",
"null",
";",
"string",
"uuid",
"=",
"null",
";",
"snapshot",
"state",
"state",
"=",
"null",
";",
"map",
"<",
"string",
",",
"string",
">",
"meta",
"generations",
"=",
"null",
";",
"version",
"version",
"=",
"null",
";",
"while",
"(",
"parser",
"next",
"token",
"(",
")",
"!",
"=",
"x",
"content",
"parser",
"token",
"end",
"object",
")",
"{",
"string",
"current",
"field",
"name",
"=",
"parser",
"current",
"name",
"(",
")",
";",
"parser",
"next",
"token",
"(",
")",
";",
"switch",
"(",
"current",
"field",
"name",
")",
"{",
"case",
"name",
":",
"name",
"=",
"parser",
"text",
"(",
")",
";",
"break",
";",
"case",
"uuid",
":",
"uuid",
"=",
"parser",
"text",
"(",
")",
";",
"break",
";",
"case",
"state",
":",
"state",
"=",
"snapshot",
"state",
"from",
"value",
"(",
"(",
"byte",
")",
"parser",
"int",
"value",
"(",
")",
")",
";",
"break",
";",
"case",
"index",
"metadata",
"lookup",
":",
"meta",
"generations",
"=",
"parser",
"map",
"(",
"hash",
"map",
":",
":",
"new",
",",
"p",
"-",
">",
"string",
"deduplicator",
"compute",
"if",
"absent",
"(",
"p",
"text",
"(",
")",
",",
"function",
"identity",
"(",
")",
")",
")",
";",
"break",
";",
"case",
"version",
":",
"version",
"=",
"version",
"from",
"string",
"(",
"parser",
"text",
"(",
")",
")",
";",
"break",
";",
"}",
"}",
"final",
"snapshot",
"id",
"snapshot",
"id",
"=",
"new",
"snapshot",
"id",
"(",
"name",
",",
"uuid",
")",
";",
"if",
"(",
"state",
"!",
"=",
"null",
")",
"{",
"snapshot",
"states",
"put",
"(",
"uuid",
",",
"state",
")",
";",
"}",
"if",
"(",
"version",
"!",
"=",
"null",
")",
"{",
"snapshot",
"versions",
"put",
"(",
"uuid",
",",
"version",
")",
";",
"}",
"snapshots",
"put",
"(",
"uuid",
",",
"snapshot",
"id",
")",
";",
"if",
"(",
"meta",
"generations",
"!",
"=",
"null",
"&",
"&",
"meta",
"generations",
"is",
"empty",
"(",
")",
"=",
"=",
"false",
")",
"{",
"index",
"meta",
"lookup",
"put",
"(",
"snapshot",
"id",
",",
"meta",
"generations",
")",
";",
"}",
"}",
"}"
] |
[
"\\",
"sum",
"i",
"func",
"(",
"x",
"1",
"i",
",",
"x",
"2",
"i",
")"
] |
[
"public",
"static",
"double",
"apply",
"sum",
"(",
"sparse",
"vector",
"x",
"1",
",",
"dense",
"vector",
"x",
"2",
",",
"bi",
"function",
"<",
"double",
",",
"double",
",",
"double",
">",
"func",
")",
"{",
"assert",
"x",
"1",
"size",
"(",
")",
"=",
"=",
"x",
"2",
"size",
"(",
")",
":",
"\"",
"x",
"1",
"and",
"x",
"2",
"size",
"mismatched",
"\"",
";",
"double",
"s",
"=",
"0",
";",
"int",
"p",
"1",
"=",
"0",
";",
"int",
"[",
"]",
"x",
"1",
"indices",
"=",
"x",
"1",
"get",
"indices",
"(",
")",
";",
"double",
"[",
"]",
"x",
"1",
"values",
"=",
"x",
"1",
"get",
"values",
"(",
")",
";",
"int",
"nnz",
"1",
"=",
"x",
"1",
"indices",
"length",
";",
"double",
"[",
"]",
"x",
"2data",
"=",
"x",
"2",
"get",
"data",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"x",
"2data",
"length",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"p",
"1",
"<",
"nnz",
"1",
"&",
"&",
"x",
"1",
"indices",
"[",
"p",
"1",
"]",
"=",
"=",
"i",
")",
"{",
"s",
"+",
"=",
"func",
"apply",
"(",
"x",
"1",
"values",
"[",
"p",
"1",
"]",
",",
"x",
"2data",
"[",
"i",
"]",
")",
";",
"p",
"1",
"+",
"+",
";",
"}",
"else",
"{",
"s",
"+",
"=",
"func",
"apply",
"(",
"0",
",",
"x",
"2data",
"[",
"i",
"]",
")",
";",
"}",
"}",
"return",
"s",
";",
"}"
] |
[
"verify",
"that",
"acl",
"optimization",
"of",
"storing",
"just",
"a",
"few",
"acls",
"and",
"there",
"references",
"in",
"the",
"data",
"node",
"is",
"actually",
"working"
] |
[
"public",
"void",
"test",
"acls",
"(",
")",
"throws",
"exception",
"{",
"file",
"tmp",
"dir",
"=",
"client",
"base",
"create",
"tmp",
"dir",
"(",
")",
";",
"client",
"base",
"setup",
"test",
"env",
"(",
")",
";",
"zoo",
"keeper",
"server",
"zks",
"=",
"new",
"zoo",
"keeper",
"server",
"(",
"tmp",
"dir",
",",
"tmp",
"dir",
",",
"3000",
")",
";",
"sync",
"request",
"processor",
"set",
"snap",
"count",
"(",
"1000",
")",
";",
"final",
"int",
"port",
"=",
"integer",
"parse",
"int",
"(",
"hostport",
"split",
"(",
"\"",
":",
"\"",
")",
"[",
"1",
"]",
")",
";",
"server",
"cnxn",
"factory",
"f",
"=",
"server",
"cnxn",
"factory",
"create",
"factory",
"(",
"port",
",",
"-",
"1",
")",
";",
"f",
"startup",
"(",
"zks",
")",
";",
"zoo",
"keeper",
"zk",
";",
"string",
"path",
";",
"try",
"{",
"log",
"info",
"(",
"\"",
"starting",
"up",
"the",
"zookeeper",
"server",
"waiting",
"\"",
")",
";",
"assert",
"true",
"(",
"client",
"base",
"wait",
"for",
"server",
"up",
"(",
"hostport",
",",
"connection",
"timeout",
")",
",",
"\"",
"waiting",
"for",
"server",
"being",
"up",
"\"",
")",
";",
"zk",
"=",
"client",
"base",
"create",
"z",
"k",
"client",
"(",
"hostport",
")",
";",
"log",
"info",
"(",
"\"",
"starting",
"creating",
"acls",
"\"",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"100",
";",
"i",
"+",
"+",
")",
"{",
"path",
"=",
"\"",
"/",
"\"",
"+",
"i",
";",
"zk",
"create",
"(",
"path",
",",
"path",
"get",
"bytes",
"(",
")",
",",
"ids",
"open",
"acl",
"unsafe",
",",
"create",
"mode",
"persistent",
")",
";",
"}",
"int",
"size",
"=",
"zks",
"get",
"z",
"k",
"database",
"(",
")",
"get",
"acl",
"size",
"(",
")",
";",
"assert",
"true",
"(",
"(",
"2",
"=",
"=",
"zks",
"get",
"z",
"k",
"database",
"(",
")",
"get",
"acl",
"size",
"(",
")",
")",
",",
"\"",
"size",
"of",
"the",
"acl",
"map",
"\"",
")",
";",
"for",
"(",
"int",
"j",
"=",
"100",
";",
"j",
"<",
"200",
";",
"j",
"+",
"+",
")",
"{",
"path",
"=",
"\"",
"/",
"\"",
"+",
"j",
";",
"acl",
"acl",
"=",
"new",
"acl",
"(",
")",
";",
"acl",
"set",
"perms",
"(",
"0",
")",
";",
"id",
"id",
"=",
"new",
"id",
"(",
")",
";",
"id",
"set",
"id",
"(",
"\"",
"1",
"1",
"1",
"\"",
"+",
"j",
")",
";",
"id",
"set",
"scheme",
"(",
"\"",
"ip",
"\"",
")",
";",
"acl",
"set",
"id",
"(",
"id",
")",
";",
"list",
"<",
"acl",
">",
"list",
"=",
"new",
"array",
"list",
"<",
"acl",
">",
"(",
")",
";",
"list",
"add",
"(",
"acl",
")",
";",
"zk",
"create",
"(",
"path",
",",
"path",
"get",
"bytes",
"(",
")",
",",
"list",
",",
"create",
"mode",
"persistent",
")",
";",
"}",
"assert",
"true",
"(",
"(",
"102",
"=",
"=",
"zks",
"get",
"z",
"k",
"database",
"(",
")",
"get",
"acl",
"size",
"(",
")",
")",
",",
"\"",
"size",
"of",
"the",
"acl",
"map",
"\"",
")",
";",
"}",
"finally",
"{",
"/",
"/",
"now",
"shutdown",
"the",
"server",
"and",
"restart",
"it",
"f",
"shutdown",
"(",
")",
";",
"zks",
"shutdown",
"(",
")",
";",
"assert",
"true",
"(",
"client",
"base",
"wait",
"for",
"server",
"down",
"(",
"hostport",
",",
"connection",
"timeout",
")",
",",
"\"",
"waiting",
"for",
"server",
"down",
"\"",
")",
";",
"}",
"zks",
"=",
"new",
"zoo",
"keeper",
"server",
"(",
"tmp",
"dir",
",",
"tmp",
"dir",
",",
"3000",
")",
";",
"f",
"=",
"server",
"cnxn",
"factory",
"create",
"factory",
"(",
"port",
",",
"-",
"1",
")",
";",
"f",
"startup",
"(",
"zks",
")",
";",
"try",
"{",
"assert",
"true",
"(",
"client",
"base",
"wait",
"for",
"server",
"up",
"(",
"hostport",
",",
"connection",
"timeout",
")",
",",
"\"",
"waiting",
"for",
"server",
"up",
"\"",
")",
";",
"zk",
"=",
"client",
"base",
"create",
"z",
"k",
"client",
"(",
"hostport",
")",
";",
"assert",
"true",
"(",
"(",
"102",
"=",
"=",
"zks",
"get",
"z",
"k",
"database",
"(",
")",
"get",
"acl",
"size",
"(",
")",
")",
",",
"\"",
"acl",
"map",
"\"",
")",
";",
"for",
"(",
"int",
"j",
"=",
"200",
";",
"j",
"<",
"205",
";",
"j",
"+",
"+",
")",
"{",
"path",
"=",
"\"",
"/",
"\"",
"+",
"j",
";",
"acl",
"acl",
"=",
"new",
"acl",
"(",
")",
";",
"acl",
"set",
"perms",
"(",
"0",
")",
";",
"id",
"id",
"=",
"new",
"id",
"(",
")",
";",
"id",
"set",
"id",
"(",
"\"",
"1",
"1",
"1",
"\"",
"+",
"j",
")",
";",
"id",
"set",
"scheme",
"(",
"\"",
"ip",
"\"",
")",
";",
"acl",
"set",
"id",
"(",
"id",
")",
";",
"array",
"list",
"<",
"acl",
">",
"list",
"=",
"new",
"array",
"list",
"<",
"acl",
">",
"(",
")",
";",
"list",
"add",
"(",
"acl",
")",
";",
"zk",
"create",
"(",
"path",
",",
"path",
"get",
"bytes",
"(",
")",
",",
"list",
",",
"create",
"mode",
"persistent",
")",
";",
"}",
"assert",
"true",
"(",
"(",
"107",
"=",
"=",
"zks",
"get",
"z",
"k",
"database",
"(",
")",
"get",
"acl",
"size",
"(",
")",
")",
",",
"\"",
"acl",
"map",
"\"",
")",
";",
"zk",
"close",
"(",
")",
";",
"}",
"finally",
"{",
"f",
"shutdown",
"(",
")",
";",
"zks",
"shutdown",
"(",
")",
";",
"assert",
"true",
"(",
"client",
"base",
"wait",
"for",
"server",
"down",
"(",
"hostport",
",",
"client",
"base",
"connection",
"timeout",
")",
",",
"\"",
"waiting",
"for",
"server",
"down",
"\"",
")",
";",
"}",
"}"
] |
[
"get",
"attribute",
"integer"
] |
[
"public",
"integer",
"get",
"attribute",
"integer",
"(",
")",
"{",
"return",
"attribute",
"integer",
";",
"}"
] |
[
"return",
"headers",
"to",
"add",
"to",
"the",
"response"
] |
[
"http",
"headers",
"headers",
"(",
")",
";"
] |
[
"get",
"the",
"comma",
"delimited",
"values",
"of",
"the",
"<",
"code",
">",
"name",
"<",
"code",
">",
"property",
"as",
"a",
"collection",
"of",
"<",
"code",
">",
"string",
"<",
"code",
">",
"s",
"if",
"no",
"such",
"property",
"is",
"specified",
"then",
"empty",
"collection",
"is",
"returned",
"this",
"is",
"an",
"optimized",
"version",
"of",
"{",
"@",
"link",
"#",
"get",
"strings",
"(",
"string",
")",
"}"
] |
[
"public",
"collection",
"<",
"string",
">",
"get",
"string",
"collection",
"(",
"string",
"name",
")",
"{",
"string",
"value",
"string",
"=",
"get",
"(",
"name",
")",
";",
"return",
"string",
"utils",
"get",
"string",
"collection",
"(",
"value",
"string",
")",
";",
"}"
] |
[
"generate",
"warning",
"log",
"entry",
"and",
"bookmark",
"at",
"relocation",
"address",
"where",
"import",
"issue",
"occurred"
] |
[
"public",
"static",
"void",
"mark",
"as",
"warning",
"(",
"program",
"program",
",",
"address",
"relocation",
"address",
",",
"string",
"type",
",",
"string",
"msg",
",",
"message",
"log",
"log",
")",
"{",
"mark",
"as",
"warning",
"(",
"program",
",",
"relocation",
"address",
",",
"type",
",",
"null",
",",
"0",
",",
"msg",
",",
"log",
")",
";",
"}"
] |
[
"string",
"argument",
"that",
"contains",
"a",
"substring",
"that",
"matches",
"the",
"given",
"regular",
"expression"
] |
[
"public",
"static",
"string",
"find",
"(",
"string",
"regex",
")",
"{",
"report",
"matcher",
"(",
"new",
"find",
"(",
"regex",
")",
")",
";",
"return",
"null",
";",
"}"
] |
[
"show",
"a",
"notification",
"using",
"the",
"balloon",
"api",
"instead",
"of",
"the",
"bus",
"credit",
"to",
"@",
"vladsch"
] |
[
"private",
"static",
"void",
"show",
"full",
"notification",
"(",
"final",
"project",
"project",
",",
"final",
"notification",
"notification",
")",
"{",
"{",
"final",
"ide",
"frame",
"frame",
"=",
"window",
"manager",
"get",
"instance",
"(",
")",
"get",
"ide",
"frame",
"(",
"project",
")",
";",
"final",
"rectangle",
"bounds",
"=",
"objects",
"require",
"non",
"null",
"(",
"frame",
")",
"get",
"component",
"(",
")",
"get",
"bounds",
"(",
")",
";",
"final",
"relative",
"point",
"target",
"=",
"new",
"relative",
"point",
"(",
"frame",
"get",
"component",
"(",
")",
",",
"new",
"point",
"(",
"bounds",
"x",
"+",
"bounds",
"width",
",",
"20",
")",
")",
";",
"try",
"{",
"/",
"/",
"create",
"a",
"notification",
"balloon",
"using",
"the",
"manager",
"final",
"balloon",
"balloon",
"=",
"notifications",
"manager",
"impl",
"create",
"balloon",
"(",
"frame",
",",
"notification",
",",
"true",
",",
"true",
",",
"balloon",
"layout",
"data",
"full",
"content",
"(",
")",
",",
"m",
"t",
"theme",
"manager",
"get",
"instance",
"(",
")",
")",
";",
"/",
"/",
"display",
"the",
"balloon",
"at",
"the",
"top",
"right",
"balloon",
"show",
"(",
"target",
",",
"balloon",
"position",
"at",
"left",
")",
";",
"}",
"catch",
"(",
"final",
"no",
"such",
"method",
"error",
"|",
"no",
"class",
"def",
"found",
"error",
"|",
"no",
"such",
"field",
"error",
"e",
")",
"{",
"notification",
"notify",
"(",
"project",
")",
";",
"}",
"}",
"}"
] |
[
"makes",
"a",
"copy",
"of",
"this",
"model"
] |
[
"public",
"listing",
"model",
"copy",
"(",
")",
";"
] |
[
"return",
"the",
"sampler",
"slot",
"start"
] |
[
"public",
"long",
"get",
"sampler",
"slot",
"start",
"(",
")",
"{",
"return",
"sampler",
"slot",
"start",
";",
"}"
] |
[
"cancels",
"this",
"execution",
"vertex"
] |
[
"public",
"completable",
"future",
"<",
"?",
">",
"cancel",
"(",
")",
"{",
"/",
"/",
"to",
"avoid",
"any",
"case",
"of",
"mixup",
"in",
"the",
"presence",
"of",
"concurrent",
"calls",
",",
"/",
"/",
"we",
"copy",
"a",
"reference",
"to",
"the",
"stack",
"to",
"make",
"sure",
"both",
"calls",
"go",
"to",
"the",
"same",
"execution",
"final",
"execution",
"exec",
"=",
"current",
"execution",
";",
"exec",
"cancel",
"(",
")",
";",
"return",
"exec",
"get",
"release",
"future",
"(",
")",
";",
"}"
] |
[
"to",
"test",
"the",
"collection",
"format",
"in",
"query",
"parameters"
] |
[
"public",
"void",
"test",
"query",
"parameter",
"collection",
"format",
"test",
"(",
")",
"throws",
"api",
"exception",
"{",
"list",
"<",
"string",
">",
"pipe",
"=",
"null",
";",
"list",
"<",
"string",
">",
"ioutil",
"=",
"null",
";",
"list",
"<",
"string",
">",
"http",
"=",
"null",
";",
"list",
"<",
"string",
">",
"url",
"=",
"null",
";",
"list",
"<",
"string",
">",
"context",
"=",
"null",
";",
"api",
"test",
"query",
"parameter",
"collection",
"format",
"(",
"pipe",
",",
"ioutil",
",",
"http",
",",
"url",
",",
"context",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
] |
[
"the",
"timestamp",
"of",
"the",
"record",
"will",
"never",
"be",
"negative"
] |
[
"public",
"long",
"timestamp",
"(",
")",
"{",
"return",
"timestamp",
";",
"}"
] |
[
"gets",
"the",
"specified",
"comparator",
"from",
"this",
"plan",
"node"
] |
[
"public",
"type",
"comparator",
"factory",
"<",
"?",
">",
"get",
"comparator",
"(",
"int",
"id",
")",
"{",
"return",
"comparators",
"[",
"id",
"]",
";",
"}"
] |
[
"returns",
"an",
"immutable",
"set",
"of",
"all",
"nine",
"primitive",
"types",
"(",
"including",
"{",
"@",
"code",
"void",
"}",
")",
"note",
"that",
"a",
"simpler",
"way",
"to",
"test",
"whether",
"a",
"{",
"@",
"code",
"class",
"}",
"instance",
"is",
"a",
"member",
"of",
"this",
"set",
"is",
"to",
"call",
"{",
"@",
"link",
"class",
"#",
"is",
"primitive",
"}"
] |
[
"public",
"static",
"set",
"<",
"class",
"<",
"?",
">",
">",
"all",
"primitive",
"types",
"(",
")",
"{",
"return",
"primitive",
"to",
"wrapper",
"type",
"key",
"set",
"(",
")",
";",
"}"
] |
[
"helper",
"method",
"to",
"build",
"downstream",
"tls",
"context",
"for",
"cert",
"provider",
"tests"
] |
[
"public",
"static",
"envoy",
"server",
"proto",
"data",
"downstream",
"tls",
"context",
"build",
"downstream",
"tls",
"context",
"for",
"cert",
"provider",
"instance",
"(",
"@",
"nullable",
"string",
"cert",
"instance",
"name",
",",
"@",
"nullable",
"string",
"cert",
"name",
",",
"@",
"nullable",
"string",
"root",
"instance",
"name",
",",
"@",
"nullable",
"string",
"root",
"cert",
"name",
",",
"iterable",
"<",
"string",
">",
"alpn",
"protocols",
",",
"certificate",
"validation",
"context",
"static",
"cert",
"validation",
"context",
",",
"boolean",
"require",
"client",
"cert",
")",
"{",
"return",
"build",
"internal",
"downstream",
"tls",
"context",
"(",
"build",
"common",
"tls",
"context",
"for",
"cert",
"provider",
"instance",
"(",
"cert",
"instance",
"name",
",",
"cert",
"name",
",",
"root",
"instance",
"name",
",",
"root",
"cert",
"name",
",",
"alpn",
"protocols",
",",
"static",
"cert",
"validation",
"context",
")",
",",
"require",
"client",
"cert",
")",
";",
"}"
] |
[
"build",
"an",
"instance",
"of",
"{",
"@",
"code",
"websocket",
"client",
"spec",
"}",
"that",
"reflects",
"the",
"current",
"configuration",
"this",
"can",
"be",
"used",
"to",
"check",
"the",
"configured",
"parameters",
"except",
"for",
"sub",
"-",
"protocols",
"which",
"depend",
"on",
"the",
"{",
"@",
"link",
"web",
"socket",
"handler",
"}",
"that",
"is",
"used",
"for",
"a",
"given",
"upgrade"
] |
[
"public",
"websocket",
"client",
"spec",
"get",
"websocket",
"client",
"spec",
"(",
")",
"{",
"return",
"build",
"spec",
"(",
"null",
")",
";",
"}"
] |
[
"determine",
"a",
"suggested",
"value",
"from",
"any",
"of",
"the",
"given",
"candidate",
"annotations"
] |
[
"protected",
"object",
"find",
"value",
"(",
"annotation",
"[",
"]",
"annotations",
"to",
"search",
")",
"{",
"if",
"(",
"annotations",
"to",
"search",
"length",
">",
"0",
")",
"{",
"/",
"/",
"qualifier",
"annotations",
"have",
"to",
"be",
"local",
"annotation",
"attributes",
"attr",
"=",
"annotated",
"element",
"utils",
"get",
"merged",
"annotation",
"attributes",
"(",
"annotated",
"element",
"utils",
"for",
"annotations",
"(",
"annotations",
"to",
"search",
")",
",",
"this",
"value",
"annotation",
"type",
")",
";",
"if",
"(",
"attr",
"!",
"=",
"null",
")",
"{",
"return",
"extract",
"value",
"(",
"attr",
")",
";",
"}",
"}",
"return",
"null",
";",
"}"
] |
[
"install",
"any",
"services",
"that",
"are",
"not",
"provided",
"by",
"plugins"
] |
[
"private",
"void",
"install",
"services",
"(",
")",
"{",
"service",
"mgr",
"add",
"service",
"(",
"project",
"data",
"service",
"class",
",",
"(",
"project",
"data",
"service",
")",
"(",
")",
"-",
">",
"project",
"get",
"project",
"data",
"(",
")",
")",
";",
"}"
] |
[
"triggers",
"deployment",
"of",
"a",
"cluster"
] |
[
"cluster",
"client",
"provider",
"<",
"t",
">",
"deploy",
"session",
"cluster",
"(",
"cluster",
"specification",
"cluster",
"specification",
")",
"throws",
"cluster",
"deployment",
"exception",
";"
] |
[
"computes",
"the",
"logarithm",
"of",
"the",
"given",
"value",
"to",
"the",
"base",
"of",
"2",
"this",
"method",
"throws",
"an",
"error",
",",
"if",
"the",
"given",
"argument",
"is",
"not",
"a",
"power",
"of",
"2"
] |
[
"public",
"static",
"int",
"log",
"2strict",
"(",
"int",
"value",
")",
"throws",
"arithmetic",
"exception",
",",
"illegal",
"argument",
"exception",
"{",
"if",
"(",
"value",
"=",
"=",
"0",
")",
"{",
"throw",
"new",
"arithmetic",
"exception",
"(",
"\"",
"logarithm",
"of",
"zero",
"is",
"undefined",
"\"",
")",
";",
"}",
"if",
"(",
"(",
"value",
"&",
"(",
"value",
"-",
"1",
")",
")",
"!",
"=",
"0",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"the",
"given",
"value",
"\"",
"+",
"value",
"+",
"\"",
"is",
"not",
"a",
"power",
"of",
"two",
"\"",
")",
";",
"}",
"return",
"31",
"-",
"integer",
"number",
"of",
"leading",
"zeros",
"(",
"value",
")",
";",
"}"
] |
[
"converts",
"an",
"integer",
"to",
"a",
"long"
] |
[
"public",
"static",
"long",
"int",
"to",
"long",
"(",
"int",
"i",
")",
"{",
"return",
"(",
"i",
"&",
"int",
"mask",
")",
";",
"}"
] |
[
"create",
"an",
"instance",
"of",
"the",
"given",
"class"
] |
[
"public",
"static",
"object",
"create",
"instance",
"(",
"string",
"class",
"name",
")",
"{",
"return",
"org",
"apache",
"hadoop",
"mapreduce",
"lib",
"aggregate",
"user",
"defined",
"value",
"aggregator",
"descriptor",
"create",
"instance",
"(",
"class",
"name",
")",
";",
"}"
] |
[
"gets",
"whether",
"image",
"should",
"be",
"scaled",
"down",
"inside",
"borders"
] |
[
"public",
"boolean",
"get",
"scale",
"down",
"inside",
"borders",
"(",
")",
"{",
"return",
"m",
"scale",
"down",
"inside",
"borders",
";",
"}"
] |
[
"test",
"user",
"-",
"defined",
"grouping",
"comparator",
"for",
"grouping",
"values",
"in",
"reduce",
"we",
"generate",
"composite",
"keys",
"that",
"contain",
"a",
"random",
"number",
",",
"which",
"acts",
"as",
"a",
"timestamp",
"associated",
"with",
"the",
"record",
"in",
"our",
"reduce",
"function",
",",
"values",
"for",
"a",
"key",
"should",
"be",
"sorted",
"by",
"the",
"'",
"timestamp",
"'"
] |
[
"public",
"void",
"test",
"user",
"value",
"grouping",
"comparator",
"(",
")",
"throws",
"exception",
"{",
"conf",
"set",
"mapper",
"class",
"(",
"random",
"gen",
"mapper",
"class",
")",
";",
"conf",
"set",
"reducer",
"class",
"(",
"ascending",
"group",
"reducer",
"class",
")",
";",
"conf",
"set",
"output",
"value",
"grouping",
"comparator",
"(",
"composite",
"int",
"group",
"fn",
"class",
")",
";",
"running",
"job",
"r",
"job",
"=",
"jc",
"submit",
"job",
"(",
"conf",
")",
";",
"while",
"(",
"!",
"r",
"job",
"is",
"complete",
"(",
")",
")",
"{",
"thread",
"sleep",
"(",
"1000",
")",
";",
"}",
"if",
"(",
"!",
"r",
"job",
"is",
"successful",
"(",
")",
")",
"{",
"fail",
"(",
"\"",
"oops",
"!",
"the",
"job",
"broke",
"due",
"to",
"an",
"unexpected",
"error",
"\"",
")",
";",
"}",
"}"
] |
[
"test",
"the",
"property",
"'",
"map",
"with",
"undeclared",
"properties",
"anytype",
"2",
"'"
] |
[
"public",
"void",
"map",
"with",
"undeclared",
"properties",
"anytype",
"2",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"map",
"with",
"undeclared",
"properties",
"anytype",
"2",
"}"
] |
[
"returns",
"<",
"code",
">",
"true",
"<",
"code",
">",
"iff",
"the",
"results",
"should",
"be",
"merged",
"note",
"that",
"when",
"using",
"the",
"high",
"-",
"level",
"rest",
"client",
",",
"results",
"are",
"always",
"merged",
"(",
"this",
"flag",
"is",
"always",
"considered",
"'",
"true",
"'",
")"
] |
[
"boolean",
"is",
"merge",
"results",
"(",
")",
"{",
"return",
"merge",
"results",
";",
"}"
] |
[
"return",
"the",
"arguments",
"for",
"the",
"target",
"method",
"call"
] |
[
"public",
"object",
"[",
"]",
"get",
"arguments",
"(",
")",
"{",
"return",
"this",
"arguments",
";",
"}"
] |
[
"read",
"a",
"line",
"terminated",
"by",
"a",
"custom",
"delimiter"
] |
[
"private",
"int",
"read",
"custom",
"line",
"(",
"text",
"str",
",",
"int",
"max",
"line",
"length",
",",
"int",
"max",
"bytes",
"to",
"consume",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"*",
"we",
"'",
"re",
"reading",
"data",
"from",
"input",
"stream",
",",
"but",
"the",
"head",
"of",
"the",
"stream",
"may",
"be",
"*",
"already",
"captured",
"in",
"the",
"previous",
"buffer",
",",
"so",
"we",
"have",
"several",
"cases",
":",
"*",
"*",
"1",
"the",
"buffer",
"tail",
"does",
"not",
"contain",
"any",
"character",
"sequence",
"which",
"*",
"matches",
"with",
"the",
"head",
"of",
"delimiter",
"we",
"count",
"it",
"as",
"a",
"*",
"ambiguous",
"byte",
"count",
"=",
"0",
"*",
"*",
"2",
"the",
"buffer",
"tail",
"contains",
"a",
"x",
"number",
"of",
"characters",
",",
"*",
"that",
"forms",
"a",
"sequence",
",",
"which",
"matches",
"with",
"the",
"*",
"head",
"of",
"delimiter",
"we",
"count",
"ambiguous",
"byte",
"count",
"=",
"x",
"*",
"*",
"/",
"/",
"*",
"*",
"*",
"eg",
":",
"a",
"segment",
"of",
"input",
"file",
"is",
"as",
"follows",
"*",
"*",
"\"",
"record",
"1792",
":",
"i",
"found",
"this",
"bug",
"very",
"interesting",
"and",
"*",
"i",
"have",
"completely",
"read",
"about",
"it",
"record",
"1793",
":",
"this",
"bug",
"*",
"can",
"be",
"solved",
"easily",
"record",
"1794",
":",
"this",
"\"",
"*",
"*",
"delimiter",
"=",
"\"",
"record",
"\"",
";",
"*",
"*",
"supposing",
":",
"-",
"string",
"at",
"the",
"end",
"of",
"buffer",
"=",
"*",
"\"",
"i",
"found",
"this",
"bug",
"very",
"interesting",
"and",
"i",
"have",
"completely",
"re",
"\"",
"*",
"there",
"for",
"next",
"buffer",
"=",
"\"",
"ad",
"about",
"it",
"record",
"179",
"\"",
"*",
"*",
"the",
"matching",
"characters",
"in",
"the",
"input",
"*",
"buffer",
"tail",
"and",
"delimiter",
"head",
"=",
"\"",
"re",
"\"",
"*",
"therefore",
",",
"ambiguous",
"byte",
"count",
"=",
"2",
"*",
"*",
"*",
"*",
"/",
"/",
"*",
"*",
"2",
"1",
"if",
"the",
"following",
"bytes",
"are",
"the",
"remaining",
"characters",
"of",
"*",
"the",
"delimiter",
",",
"then",
"we",
"have",
"to",
"capture",
"only",
"up",
"to",
"the",
"starting",
"*",
"position",
"of",
"delimiter",
"that",
"means",
",",
"we",
"need",
"not",
"include",
"the",
"*",
"ambiguous",
"characters",
"in",
"str",
"*",
"*",
"2",
"2",
"if",
"the",
"following",
"bytes",
"are",
"not",
"the",
"remaining",
"characters",
"of",
"*",
"the",
"delimiter",
"(",
"as",
"mentioned",
"in",
"the",
"example",
")",
",",
"*",
"then",
"we",
"have",
"to",
"include",
"the",
"ambiguous",
"characters",
"in",
"str",
"*",
"/",
"str",
"clear",
"(",
")",
";",
"int",
"txt",
"length",
"=",
"0",
";",
"/",
"/",
"tracks",
"str",
"get",
"length",
"(",
")",
",",
"as",
"an",
"optimization",
"long",
"bytes",
"consumed",
"=",
"0",
";",
"int",
"del",
"posn",
"=",
"0",
";",
"int",
"ambiguous",
"byte",
"count",
"=",
"0",
";",
"/",
"/",
"to",
"capture",
"the",
"ambiguous",
"characters",
"count",
"do",
"{",
"int",
"start",
"posn",
"=",
"buffer",
"posn",
";",
"/",
"/",
"start",
"from",
"previous",
"end",
"position",
"if",
"(",
"buffer",
"posn",
">",
"=",
"buffer",
"length",
")",
"{",
"start",
"posn",
"=",
"buffer",
"posn",
"=",
"0",
";",
"buffer",
"length",
"=",
"fill",
"buffer",
"(",
"in",
",",
"buffer",
",",
"ambiguous",
"byte",
"count",
">",
"0",
")",
";",
"if",
"(",
"buffer",
"length",
"<",
"=",
"0",
")",
"{",
"if",
"(",
"ambiguous",
"byte",
"count",
">",
"0",
")",
"{",
"str",
"append",
"(",
"record",
"delimiter",
"bytes",
",",
"0",
",",
"ambiguous",
"byte",
"count",
")",
";",
"bytes",
"consumed",
"+",
"=",
"ambiguous",
"byte",
"count",
";",
"}",
"break",
";",
"/",
"/",
"eof",
"}",
"}",
"for",
"(",
";",
"buffer",
"posn",
"<",
"buffer",
"length",
";",
"+",
"+",
"buffer",
"posn",
")",
"{",
"if",
"(",
"buffer",
"[",
"buffer",
"posn",
"]",
"=",
"=",
"record",
"delimiter",
"bytes",
"[",
"del",
"posn",
"]",
")",
"{",
"del",
"posn",
"+",
"+",
";",
"if",
"(",
"del",
"posn",
">",
"=",
"record",
"delimiter",
"bytes",
"length",
")",
"{",
"buffer",
"posn",
"+",
"+",
";",
"break",
";",
"}",
"}",
"else",
"if",
"(",
"del",
"posn",
"!",
"=",
"0",
")",
"{",
"buffer",
"posn",
"-",
"=",
"del",
"posn",
";",
"if",
"(",
"buffer",
"posn",
"<",
"-",
"1",
")",
"{",
"buffer",
"posn",
"=",
"-",
"1",
";",
"}",
"del",
"posn",
"=",
"0",
";",
"}",
"}",
"int",
"read",
"length",
"=",
"buffer",
"posn",
"-",
"start",
"posn",
";",
"bytes",
"consumed",
"+",
"=",
"read",
"length",
";",
"int",
"append",
"length",
"=",
"read",
"length",
"-",
"del",
"posn",
";",
"if",
"(",
"append",
"length",
">",
"max",
"line",
"length",
"-",
"txt",
"length",
")",
"{",
"append",
"length",
"=",
"max",
"line",
"length",
"-",
"txt",
"length",
";",
"}",
"bytes",
"consumed",
"+",
"=",
"ambiguous",
"byte",
"count",
";",
"if",
"(",
"append",
"length",
">",
"=",
"0",
"&",
"&",
"ambiguous",
"byte",
"count",
">",
"0",
")",
"{",
"/",
"/",
"appending",
"the",
"ambiguous",
"characters",
"(",
"refer",
"case",
"2",
"2",
")",
"str",
"append",
"(",
"record",
"delimiter",
"bytes",
",",
"0",
",",
"ambiguous",
"byte",
"count",
")",
";",
"ambiguous",
"byte",
"count",
"=",
"0",
";",
"/",
"/",
"since",
"it",
"is",
"now",
"certain",
"that",
"the",
"split",
"did",
"not",
"split",
"a",
"delimiter",
"we",
"/",
"/",
"should",
"not",
"read",
"the",
"next",
"record",
":",
"clear",
"the",
"flag",
"otherwise",
"duplicate",
"/",
"/",
"records",
"could",
"be",
"generated",
"unset",
"need",
"additional",
"record",
"after",
"split",
"(",
")",
";",
"}",
"if",
"(",
"append",
"length",
">",
"0",
")",
"{",
"str",
"append",
"(",
"buffer",
",",
"start",
"posn",
",",
"append",
"length",
")",
";",
"txt",
"length",
"+",
"=",
"append",
"length",
";",
"}",
"if",
"(",
"buffer",
"posn",
">",
"=",
"buffer",
"length",
")",
"{",
"if",
"(",
"del",
"posn",
">",
"0",
"&",
"&",
"del",
"posn",
"<",
"record",
"delimiter",
"bytes",
"length",
")",
"{",
"ambiguous",
"byte",
"count",
"=",
"del",
"posn",
";",
"bytes",
"consumed",
"-",
"=",
"ambiguous",
"byte",
"count",
";",
"/",
"/",
"to",
"be",
"consumed",
"in",
"next",
"}",
"}",
"}",
"while",
"(",
"del",
"posn",
"<",
"record",
"delimiter",
"bytes",
"length",
"&",
"&",
"bytes",
"consumed",
"<",
"max",
"bytes",
"to",
"consume",
")",
";",
"if",
"(",
"bytes",
"consumed",
">",
"integer",
"max",
"value",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"too",
"many",
"bytes",
"before",
"delimiter",
":",
"\"",
"+",
"bytes",
"consumed",
")",
";",
"}",
"return",
"(",
"int",
")",
"bytes",
"consumed",
";",
"}"
] |
[
"checks",
"whether",
"the",
"given",
"throwable",
"contains",
"the",
"given",
"cause",
"as",
"a",
"cause",
"the",
"cause",
"is",
"not",
"checked",
"on",
"equality",
"but",
"on",
"type",
"equality"
] |
[
"public",
"static",
"boolean",
"contains",
"cause",
"(",
"throwable",
"throwable",
",",
"class",
"<",
"?",
"extends",
"throwable",
">",
"cause",
")",
"{",
"throwable",
"current",
"=",
"throwable",
";",
"while",
"(",
"current",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"cause",
"is",
"assignable",
"from",
"(",
"current",
"get",
"class",
"(",
")",
")",
")",
"{",
"return",
"true",
";",
"}",
"current",
"=",
"current",
"get",
"cause",
"(",
")",
";",
"}",
"return",
"false",
";",
"}"
] |
[
"get",
"all",
"registered",
"instances"
] |
[
"public",
"static",
"extension",
"list",
"<",
"computer",
"pinger",
">",
"all",
"(",
")",
"{",
"return",
"extension",
"list",
"lookup",
"(",
"computer",
"pinger",
"class",
")",
";",
"}"
] |
[
"returns",
"the",
"32",
"-",
"bit",
"rgba8888",
"value",
"of",
"the",
"pixel",
"at",
"x",
",",
"y",
"for",
"alpha",
"formats",
"the",
"rgb",
"components",
"will",
"be",
"one"
] |
[
"public",
"int",
"get",
"pixel",
"(",
"int",
"x",
",",
"int",
"y",
")",
"{",
"ensure",
"canvas",
"exists",
"(",
")",
";",
"if",
"(",
"pixels",
"=",
"=",
"null",
")",
"pixels",
"=",
"context",
"get",
"image",
"data",
"(",
"0",
",",
"0",
",",
"width",
",",
"height",
")",
"get",
"data",
"(",
")",
";",
"int",
"i",
"=",
"x",
"*",
"4",
"+",
"y",
"*",
"width",
"*",
"4",
";",
"int",
"r",
"=",
"pixels",
"get",
"(",
"i",
"+",
"0",
")",
"&",
"0xff",
";",
"int",
"g",
"=",
"pixels",
"get",
"(",
"i",
"+",
"1",
")",
"&",
"0xff",
";",
"int",
"b",
"=",
"pixels",
"get",
"(",
"i",
"+",
"2",
")",
"&",
"0xff",
";",
"int",
"a",
"=",
"pixels",
"get",
"(",
"i",
"+",
"3",
")",
"&",
"0xff",
";",
"return",
"(",
"r",
"<",
"<",
"24",
")",
"|",
"(",
"g",
"<",
"<",
"16",
")",
"|",
"(",
"b",
"<",
"<",
"8",
")",
"|",
"(",
"a",
")",
";",
"}"
] |
[
"verify",
"if",
"the",
"time",
"per",
"execution",
"of",
"a",
"task",
"matches",
"the",
"actual",
"time",
"required",
"to",
"execute",
"the",
"task",
"a",
"given",
"number",
"of",
"times"
] |
[
"public",
"void",
"test",
"time",
"ms",
"(",
")",
"{",
"for",
"(",
"var",
"i",
"=",
"0",
";",
"i",
"<",
"10",
";",
"i",
"+",
"+",
")",
"{",
"assert",
"equals",
"(",
"this",
"expected",
"execution",
"time",
"*",
"i",
",",
"this",
"factory",
"apply",
"(",
"i",
")",
"get",
"time",
"ms",
"(",
")",
")",
";",
"}",
"}"
] |
[
"evaluate",
"the",
"server",
"provided",
"challenge",
"the",
"server",
"must",
"send",
"a",
"token",
"if",
"it",
"'",
"s",
"not",
"done",
"if",
"the",
"server",
"is",
"done",
",",
"the",
"challenge",
"token",
"is",
"optional",
"because",
"not",
"all",
"mechanisms",
"send",
"a",
"final",
"token",
"for",
"the",
"client",
"to",
"update",
"its",
"internal",
"state",
"the",
"client",
"must",
"also",
"be",
"done",
"after",
"evaluating",
"the",
"optional",
"token",
"to",
"ensure",
"a",
"malicious",
"server",
"doesn",
"'",
"t",
"prematurely",
"end",
"the",
"negotiation",
"with",
"a",
"phony",
"success"
] |
[
"private",
"byte",
"[",
"]",
"sasl",
"evaluate",
"token",
"(",
"rpc",
"sasl",
"proto",
"sasl",
"response",
",",
"boolean",
"server",
"is",
"done",
")",
"throws",
"sasl",
"exception",
"{",
"byte",
"[",
"]",
"sasl",
"token",
"=",
"null",
";",
"if",
"(",
"sasl",
"response",
"has",
"token",
"(",
")",
")",
"{",
"sasl",
"token",
"=",
"sasl",
"response",
"get",
"token",
"(",
")",
"to",
"byte",
"array",
"(",
")",
";",
"sasl",
"token",
"=",
"sasl",
"client",
"evaluate",
"challenge",
"(",
"sasl",
"token",
")",
";",
"}",
"else",
"if",
"(",
"!",
"server",
"is",
"done",
")",
"{",
"/",
"/",
"the",
"server",
"may",
"only",
"omit",
"a",
"token",
"when",
"it",
"'",
"s",
"done",
"throw",
"new",
"sasl",
"exception",
"(",
"\"",
"server",
"challenge",
"contains",
"no",
"token",
"\"",
")",
";",
"}",
"if",
"(",
"server",
"is",
"done",
")",
"{",
"/",
"/",
"server",
"tried",
"to",
"report",
"success",
"before",
"our",
"client",
"completed",
"if",
"(",
"!",
"sasl",
"client",
"is",
"complete",
"(",
")",
")",
"{",
"throw",
"new",
"sasl",
"exception",
"(",
"\"",
"client",
"is",
"out",
"of",
"sync",
"with",
"server",
"\"",
")",
";",
"}",
"/",
"/",
"a",
"client",
"cannot",
"generate",
"a",
"response",
"to",
"a",
"success",
"message",
"if",
"(",
"sasl",
"token",
"!",
"=",
"null",
")",
"{",
"throw",
"new",
"sasl",
"exception",
"(",
"\"",
"client",
"generated",
"spurious",
"response",
"\"",
")",
";",
"}",
"}",
"return",
"sasl",
"token",
";",
"}"
] |
[
"get",
"the",
"{",
"@",
"link",
"reservation",
"id",
"}",
",",
"that",
"corresponds",
"to",
"a",
"valid",
"resource",
"allocation",
"in",
"the",
"scheduler",
"(",
"between",
"start",
"and",
"end",
"time",
"of",
"this",
"reservation",
")"
] |
[
"public",
"abstract",
"reservation",
"id",
"get",
"reservation",
"id",
"(",
")",
";"
] |
[
"evaluate",
"the",
"x",
"path",
"and",
"assert",
"the",
"{",
"@",
"link",
"node",
"}",
"content",
"found",
"with",
"the",
"given",
"hamcrest",
"{",
"@",
"link",
"matcher",
"}"
] |
[
"public",
"result",
"matcher",
"node",
"(",
"matcher",
"<",
"?",
"super",
"node",
">",
"matcher",
")",
"{",
"return",
"result",
"-",
">",
"{",
"mock",
"http",
"servlet",
"response",
"response",
"=",
"result",
"get",
"response",
"(",
")",
";",
"this",
"xpath",
"helper",
"assert",
"node",
"(",
"response",
"get",
"content",
"as",
"byte",
"array",
"(",
")",
",",
"get",
"defined",
"encoding",
"(",
"response",
")",
",",
"matcher",
")",
";",
"}",
";",
"}"
] |
[
"builds",
"bytecode",
"and",
"writes",
"out",
"r",
"class",
"file",
",",
"and",
"r",
"$",
"inner",
"class",
"files",
"for",
"provided",
"package",
"and",
"symbols"
] |
[
"public",
"void",
"write",
"(",
"string",
"package",
"name",
",",
"field",
"initializers",
"symbols",
"to",
"write",
")",
"throws",
"i",
"o",
"exception",
"{",
"write",
"classes",
"(",
"package",
"name",
",",
"initializers",
"filter",
"(",
"symbols",
"to",
"write",
")",
")",
";",
"}"
] |
[
"build",
"postcard",
"by",
"path",
"and",
"group"
] |
[
"protected",
"postcard",
"build",
"(",
"string",
"path",
",",
"string",
"group",
",",
"boolean",
"after",
"replace",
")",
"{",
"if",
"(",
"text",
"utils",
"is",
"empty",
"(",
"path",
")",
"|",
"|",
"text",
"utils",
"is",
"empty",
"(",
"group",
")",
")",
"{",
"throw",
"new",
"handler",
"exception",
"(",
"consts",
"tag",
"+",
"\"",
"parameter",
"is",
"invalid",
"!",
"\"",
")",
";",
"}",
"else",
"{",
"if",
"(",
"!",
"after",
"replace",
")",
"{",
"path",
"replace",
"service",
"p",
"service",
"=",
"a",
"router",
"get",
"instance",
"(",
")",
"navigation",
"(",
"path",
"replace",
"service",
"class",
")",
";",
"if",
"(",
"null",
"!",
"=",
"p",
"service",
")",
"{",
"path",
"=",
"p",
"service",
"for",
"string",
"(",
"path",
")",
";",
"}",
"}",
"return",
"new",
"postcard",
"(",
"path",
",",
"group",
")",
";",
"}",
"}"
] |
[
"gets",
"the",
"clock",
"difference",
"in",
"html",
"string"
] |
[
"public",
"string",
"to",
"string",
"(",
")",
"{",
"if",
"(",
"-",
"1000",
"<",
"diff",
"&",
"&",
"diff",
"<",
"1000",
")",
"return",
"messages",
"clock",
"difference",
"in",
"sync",
"(",
")",
";",
"/",
"/",
"clock",
"is",
"in",
"sync",
"long",
"abs",
"=",
"math",
"abs",
"(",
"diff",
")",
";",
"string",
"s",
"=",
"util",
"get",
"time",
"span",
"string",
"(",
"abs",
")",
";",
"if",
"(",
"diff",
"<",
"0",
")",
"s",
"=",
"messages",
"clock",
"difference",
"ahead",
"(",
"s",
")",
";",
"else",
"s",
"=",
"messages",
"clock",
"difference",
"behind",
"(",
"s",
")",
";",
"return",
"s",
";",
"}"
] |
[
"double",
"doc",
"values",
"of",
"the",
"unsigned",
"long",
"field",
"type",
"are",
"already",
"in",
"the",
"formatted",
"representation",
",",
"so",
"we",
"don",
"'",
"t",
"need",
"to",
"do",
"anything",
"here"
] |
[
"public",
"double",
"format",
"(",
"double",
"value",
")",
"{",
"return",
"value",
";",
"}"
] |
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"{",
"@",
"link",
"javax",
"net",
"ssl",
"key",
"manager",
"factory",
"}",
"is",
"supported",
"when",
"using",
"open",
"s",
"s",
"l"
] |
[
"public",
"static",
"boolean",
"supports",
"key",
"manager",
"factory",
"(",
")",
"{",
"return",
"supports",
"keymanager",
"factory",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.