docstring_tokens
list | code_tokens
list |
---|---|
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
] |
[
"private",
"string",
"to",
"indented",
"string",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"gets",
"the",
"{",
"@",
"link",
"a",
"m",
"r",
"m",
"proxy",
"application",
"context",
"}"
] |
[
"public",
"a",
"m",
"r",
"m",
"proxy",
"application",
"context",
"get",
"application",
"context",
"(",
")",
"{",
"return",
"this",
"app",
"context",
";",
"}"
] |
[
"sets",
"the",
"extra",
"information",
"for",
"this",
"{",
"@",
"code",
"zip",
"entry",
"}"
] |
[
"public",
"void",
"set",
"extra",
"(",
"byte",
"[",
"]",
"data",
")",
"{",
"if",
"(",
"data",
"!",
"=",
"null",
"&",
"&",
"data",
"length",
">",
"0xffff",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"extra",
"data",
"too",
"long",
":",
"\"",
"+",
"data",
"length",
")",
";",
"}",
"extra",
"=",
"data",
";",
"}"
] |
[
"short",
"-",
"cut",
"function",
"to",
"determine",
"if",
"either",
"body",
"is",
"inactive"
] |
[
"public",
"boolean",
"is",
"active",
"(",
")",
"{",
"return",
"joint",
"is",
"active",
"(",
")",
";",
"}"
] |
[
"clear",
"all",
"associated",
"buffers"
] |
[
"private",
"void",
"clear",
"buffers",
"(",
")",
"{",
"get",
"striped",
"reader",
"(",
")",
"clear",
"buffers",
"(",
")",
";",
"striped",
"writer",
"clear",
"buffers",
"(",
")",
";",
"}"
] |
[
"start",
"the",
"watcher",
"on",
"{",
"@",
"link",
"job",
"graph",
"store",
"}"
] |
[
"void",
"start",
"(",
"job",
"graph",
"store",
"job",
"graph",
"listener",
"job",
"graph",
"listener",
")",
"throws",
"exception",
";"
] |
[
"do",
"delete",
"if",
"leader",
",",
"commit",
"delete",
"to",
"store",
"if",
"not",
"leader",
",",
"stop",
"delete",
"because",
"should",
"signal",
"to",
"leader"
] |
[
"public",
"void",
"on",
"delete",
"(",
"string",
"datum",
"key",
",",
"raft",
"peer",
"source",
")",
"throws",
"exception",
"{",
"if",
"(",
"stop",
"work",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"old",
"raft",
"protocol",
"already",
"stop",
"work",
"\"",
")",
";",
"}",
"raft",
"peer",
"local",
"=",
"peers",
"local",
"(",
")",
";",
"if",
"(",
"!",
"peers",
"is",
"leader",
"(",
"source",
"ip",
")",
")",
"{",
"loggers",
"raft",
"warn",
"(",
"\"",
"peer",
"{",
"}",
"tried",
"to",
"publish",
"data",
"but",
"wasn",
"'",
"t",
"leader",
",",
"leader",
":",
"{",
"}",
"\"",
",",
"jackson",
"utils",
"to",
"json",
"(",
"source",
")",
",",
"jackson",
"utils",
"to",
"json",
"(",
"get",
"leader",
"(",
")",
")",
")",
";",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"peer",
"(",
"\"",
"+",
"source",
"ip",
"+",
"\"",
")",
"tried",
"to",
"publish",
"data",
"but",
"wasn",
"'",
"t",
"leader",
"\"",
")",
";",
"}",
"if",
"(",
"source",
"term",
"get",
"(",
")",
"<",
"local",
"term",
"get",
"(",
")",
")",
"{",
"loggers",
"raft",
"warn",
"(",
"\"",
"out",
"of",
"date",
"publish",
",",
"pub",
"-",
"term",
":",
"{",
"}",
",",
"cur",
"-",
"term",
":",
"{",
"}",
"\"",
",",
"jackson",
"utils",
"to",
"json",
"(",
"source",
")",
",",
"jackson",
"utils",
"to",
"json",
"(",
"local",
")",
")",
";",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"out",
"of",
"date",
"publish",
",",
"pub",
"-",
"term",
":",
"\"",
"+",
"source",
"term",
"+",
"\"",
",",
"cur",
"-",
"term",
":",
"\"",
"+",
"local",
"term",
")",
";",
"}",
"local",
"reset",
"leader",
"due",
"(",
")",
";",
"/",
"/",
"do",
"apply",
"string",
"key",
"=",
"datum",
"key",
";",
"delete",
"datum",
"(",
"key",
")",
";",
"if",
"(",
"key",
"builder",
"match",
"service",
"meta",
"key",
"(",
"key",
")",
")",
"{",
"if",
"(",
"local",
"term",
"get",
"(",
")",
"+",
"publish",
"term",
"increase",
"count",
">",
"source",
"term",
"get",
"(",
")",
")",
"{",
"/",
"/",
"set",
"leader",
"term",
":",
"get",
"leader",
"(",
")",
"term",
"set",
"(",
"source",
"term",
"get",
"(",
")",
")",
";",
"local",
"term",
"set",
"(",
"get",
"leader",
"(",
")",
"term",
"get",
"(",
")",
")",
";",
"}",
"else",
"{",
"local",
"term",
"add",
"and",
"get",
"(",
"publish",
"term",
"increase",
"count",
")",
";",
"}",
"raft",
"store",
"update",
"term",
"(",
"local",
"term",
"get",
"(",
")",
")",
";",
"}",
"loggers",
"raft",
"info",
"(",
"\"",
"data",
"removed",
",",
"key",
"=",
"{",
"}",
",",
"term",
"=",
"{",
"}",
"\"",
",",
"datum",
"key",
",",
"local",
"term",
")",
";",
"}"
] |
[
"assign",
"next",
"available",
"storage",
"name"
] |
[
"private",
"synchronized",
"string",
"get",
"next",
"storage",
"name",
"(",
")",
"{",
"string",
"storage",
"name",
"=",
"string",
"utilities",
"pad",
"(",
"long",
"to",
"hex",
"string",
"(",
"next",
"file",
"index",
"i",
"d",
"+",
"+",
")",
",",
"'",
"0",
"'",
",",
"8",
")",
";",
"get",
"storage",
"dir",
"(",
"storage",
"name",
")",
";",
"/",
"/",
"ensure",
"that",
"storage",
"sub",
"-",
"directory",
"exists",
"return",
"storage",
"name",
";",
"}"
] |
[
"toggle",
"the",
"read",
"-",
"only",
"property",
"on",
"the",
"domain",
"file"
] |
[
"private",
"void",
"toggle",
"read",
"only",
"(",
"domain",
"file",
"file",
")",
"{",
"try",
"{",
"file",
"set",
"read",
"only",
"(",
"!",
"file",
"is",
"read",
"only",
"(",
")",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"msg",
"show",
"error",
"(",
"this",
",",
"null",
",",
"\"",
"error",
"setting",
"read",
"-",
"only",
"state",
"for",
"\"",
"+",
"file",
"get",
"name",
"(",
")",
",",
"e",
"get",
"message",
"(",
")",
",",
"e",
")",
";",
"}",
"}"
] |
[
"writes",
"a",
"{",
"@",
"code",
"string",
"}",
"as",
"specified",
"by",
"{",
"@",
"link",
"data",
"output",
"stream",
"#",
"write",
"chars",
"(",
"string",
")",
"}",
",",
"except",
"each",
"character",
"is",
"written",
"using",
"little",
"-",
"endian",
"byte",
"order"
] |
[
"public",
"void",
"write",
"chars",
"(",
"string",
"s",
")",
"throws",
"i",
"o",
"exception",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"s",
"length",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"write",
"char",
"(",
"s",
"char",
"at",
"(",
"i",
")",
")",
";",
"}",
"}"
] |
[
"returns",
"the",
"value",
"nearest",
"to",
"{",
"@",
"code",
"value",
"}",
"which",
"is",
"within",
"the",
"closed",
"range",
"{",
"@",
"code",
"[",
"min",
"max",
"]",
"}",
"if",
"{",
"@",
"code",
"value",
"}",
"is",
"within",
"the",
"range",
"{",
"@",
"code",
"[",
"min",
"max",
"]",
"}",
",",
"{",
"@",
"code",
"value",
"}",
"is",
"returned",
"unchanged",
"if",
"{",
"@",
"code",
"value",
"}",
"is",
"less",
"than",
"{",
"@",
"code",
"min",
"}",
",",
"{",
"@",
"code",
"min",
"}",
"is",
"returned",
",",
"and",
"if",
"{",
"@",
"code",
"value",
"}",
"is",
"greater",
"than",
"{",
"@",
"code",
"max",
"}",
",",
"{",
"@",
"code",
"max",
"}",
"is",
"returned"
] |
[
"public",
"static",
"char",
"constrain",
"to",
"range",
"(",
"char",
"value",
",",
"char",
"min",
",",
"char",
"max",
")",
"{",
"check",
"argument",
"(",
"min",
"<",
"=",
"max",
",",
"\"",
"min",
"(",
"%",
"s",
")",
"must",
"be",
"less",
"than",
"or",
"equal",
"to",
"max",
"(",
"%",
"s",
")",
"\"",
",",
"min",
",",
"max",
")",
";",
"return",
"value",
"<",
"min",
"?",
"min",
":",
"value",
"<",
"max",
"?",
"value",
":",
"max",
";",
"}"
] |
[
"set",
"the",
"name",
"of",
"this",
"message",
"endpoint",
"populated",
"with",
"the",
"bean",
"name",
"automatically",
"when",
"defined",
"within",
"spring",
"'",
"s",
"bean",
"factory"
] |
[
"public",
"void",
"set",
"bean",
"name",
"(",
"string",
"bean",
"name",
")",
"{",
"this",
"endpoint",
"factory",
"set",
"bean",
"name",
"(",
"bean",
"name",
")",
";",
"}"
] |
[
"set",
"how",
"to",
"check",
"system",
"properties",
":",
"as",
"fallback",
",",
"as",
"override",
",",
"or",
"never",
"for",
"example",
",",
"will",
"resolve",
"$",
"{",
"user",
"dir",
"}",
"to",
"the",
"\"",
"user",
"dir",
"\"",
"system",
"property",
"the",
"default",
"is",
"\"",
"fallback",
"\"",
":",
"if",
"not",
"being",
"able",
"to",
"resolve",
"a",
"placeholder",
"with",
"the",
"specified",
"properties",
",",
"a",
"system",
"property",
"will",
"be",
"tried",
"\"",
"override",
"\"",
"will",
"check",
"for",
"a",
"system",
"property",
"first",
",",
"before",
"trying",
"the",
"specified",
"properties",
"\"",
"never",
"\"",
"will",
"not",
"check",
"system",
"properties",
"at",
"all"
] |
[
"public",
"void",
"set",
"system",
"properties",
"mode",
"(",
"int",
"system",
"properties",
"mode",
")",
"{",
"this",
"system",
"properties",
"mode",
"=",
"system",
"properties",
"mode",
";",
"}"
] |
[
"returns",
"all",
"configured",
"targets",
"currently",
"in",
"the",
"graph"
] |
[
"public",
"static",
"iterable",
"<",
"configured",
"target",
">",
"get",
"all",
"existing",
"configured",
"targets",
"(",
"skyframe",
"executor",
"skyframe",
"executor",
")",
"{",
"collection",
"<",
"sky",
"value",
">",
"values",
"=",
"maps",
"filter",
"keys",
"(",
"skyframe",
"executor",
"get",
"evaluator",
"for",
"testing",
"(",
")",
"get",
"values",
"(",
")",
",",
"sky",
"functions",
"is",
"sky",
"function",
"(",
"sky",
"functions",
"configured",
"target",
")",
")",
"values",
"(",
")",
";",
"list",
"<",
"configured",
"target",
">",
"cts",
"=",
"lists",
"new",
"array",
"list",
"(",
")",
";",
"for",
"(",
"sky",
"value",
"value",
":",
"values",
")",
"{",
"if",
"(",
"value",
"!",
"=",
"null",
")",
"{",
"cts",
"add",
"(",
"(",
"(",
"configured",
"target",
"value",
")",
"value",
")",
"get",
"configured",
"target",
"(",
")",
")",
";",
"}",
"}",
"return",
"cts",
";",
"}"
] |
[
"internal",
"use",
"only",
":",
"exposes",
"the",
"internal",
"nio",
"buffer"
] |
[
"public",
"abstract",
"byte",
"buffer",
"internal",
"nio",
"buffer",
"(",
"int",
"index",
",",
"int",
"length",
")",
";"
] |
[
"set",
"the",
"list",
"of",
"response",
"headers",
"other",
"than",
"\"",
"simple",
"\"",
"headers",
",",
"i",
"e",
"{",
"@",
"code",
"cache",
"-",
"control",
"}",
",",
"{",
"@",
"code",
"content",
"-",
"language",
"}",
",",
"{",
"@",
"code",
"content",
"-",
"type",
"}",
",",
"{",
"@",
"code",
"expires",
"}",
",",
"{",
"@",
"code",
"last",
"-",
"modified",
"}",
",",
"or",
"{",
"@",
"code",
"pragma",
"}",
",",
"that",
"an",
"actual",
"response",
"might",
"have",
"and",
"can",
"be",
"exposed",
"the",
"special",
"value",
"{",
"@",
"code",
"\"",
"\"",
"}",
"allows",
"all",
"headers",
"to",
"be",
"exposed",
"for",
"non",
"-",
"credentialed",
"requests",
"by",
"default",
"this",
"is",
"not",
"set"
] |
[
"public",
"cors",
"registration",
"exposed",
"headers",
"(",
"string",
"headers",
")",
"{",
"this",
"config",
"set",
"exposed",
"headers",
"(",
"arrays",
"as",
"list",
"(",
"headers",
")",
")",
";",
"return",
"this",
";",
"}"
] |
[
"file",
"system",
"[",
"set",
"x",
"attr",
",",
"get",
"x",
"attr",
",",
"get",
"x",
"attrs",
",",
"remove",
"x",
"attr",
",",
"list",
"x",
"attrs",
"]",
"api",
"call",
"should",
"succeed",
"without",
"failure"
] |
[
"public",
"void",
"test",
"attr",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"path",
"p",
"=",
"new",
"path",
"(",
"\"",
"/",
"attr",
"test",
"\"",
")",
";",
"fs",
"mkdirs",
"(",
"p",
")",
";",
"final",
"path",
"file",
"path",
"=",
"new",
"path",
"(",
"p",
",",
"\"",
"file",
"\"",
")",
";",
"try",
"(",
"data",
"output",
"stream",
"dos",
"=",
"fs",
"create",
"(",
"file",
"path",
")",
")",
"{",
"dos",
"write",
"bytes",
"(",
"\"",
"write",
"something",
"\"",
")",
";",
"}",
"final",
"string",
"name",
"=",
"\"",
"user",
"a",
"1",
"\"",
";",
"final",
"byte",
"[",
"]",
"value",
"=",
"{",
"0x",
"3",
"1",
",",
"0x",
"3",
"2",
",",
"0x",
"3",
"3",
"}",
";",
"fs",
"set",
"x",
"attr",
"(",
"file",
"path",
",",
"name",
",",
"value",
",",
"enum",
"set",
"of",
"(",
"x",
"attr",
"set",
"flag",
"create",
")",
")",
";",
"map",
"<",
"string",
",",
"byte",
"[",
"]",
">",
"xattrs",
"=",
"fs",
"get",
"x",
"attrs",
"(",
"file",
"path",
")",
";",
"assert",
"equals",
"(",
"1",
",",
"xattrs",
"size",
"(",
")",
")",
";",
"assert",
"array",
"equals",
"(",
"value",
",",
"xattrs",
"get",
"(",
"name",
")",
")",
";",
"assert",
"array",
"equals",
"(",
"value",
",",
"fs",
"get",
"x",
"attr",
"(",
"file",
"path",
",",
"name",
")",
")",
";",
"list",
"<",
"string",
">",
"list",
"x",
"attrs",
"=",
"fs",
"list",
"x",
"attrs",
"(",
"file",
"path",
")",
";",
"assert",
"equals",
"(",
"1",
",",
"list",
"x",
"attrs",
"size",
"(",
")",
")",
";",
"fs",
"remove",
"x",
"attr",
"(",
"file",
"path",
",",
"name",
")",
";",
"xattrs",
"=",
"fs",
"get",
"x",
"attrs",
"(",
"file",
"path",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"xattrs",
"size",
"(",
")",
")",
";",
"list",
"x",
"attrs",
"=",
"fs",
"list",
"x",
"attrs",
"(",
"file",
"path",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"list",
"x",
"attrs",
"size",
"(",
")",
")",
";",
"}"
] |
[
"check",
"the",
"origin",
"of",
"the",
"request",
"against",
"the",
"configured",
"allowed",
"origins"
] |
[
"public",
"string",
"check",
"origin",
"(",
"@",
"nullable",
"string",
"request",
"origin",
")",
"{",
"if",
"(",
"!",
"string",
"utils",
"has",
"text",
"(",
"request",
"origin",
")",
")",
"{",
"return",
"null",
";",
"}",
"if",
"(",
"!",
"object",
"utils",
"is",
"empty",
"(",
"this",
"allowed",
"origins",
")",
")",
"{",
"if",
"(",
"this",
"allowed",
"origins",
"contains",
"(",
"all",
")",
")",
"{",
"validate",
"allow",
"credentials",
"(",
")",
";",
"return",
"all",
";",
"}",
"for",
"(",
"string",
"allowed",
"origin",
":",
"this",
"allowed",
"origins",
")",
"{",
"if",
"(",
"request",
"origin",
"equals",
"ignore",
"case",
"(",
"allowed",
"origin",
")",
")",
"{",
"return",
"request",
"origin",
";",
"}",
"}",
"}",
"if",
"(",
"!",
"object",
"utils",
"is",
"empty",
"(",
"this",
"allowed",
"origin",
"patterns",
")",
")",
"{",
"for",
"(",
"origin",
"pattern",
"p",
":",
"this",
"allowed",
"origin",
"patterns",
")",
"{",
"if",
"(",
"p",
"get",
"declared",
"pattern",
"(",
")",
"equals",
"(",
"all",
")",
"|",
"|",
"p",
"get",
"pattern",
"(",
")",
"matcher",
"(",
"request",
"origin",
")",
"matches",
"(",
")",
")",
"{",
"return",
"request",
"origin",
";",
"}",
"}",
"}",
"return",
"null",
";",
"}"
] |
[
"analyse",
"intends",
"to",
"parse",
"expression",
"with",
"input",
"samples",
"to",
"meter",
"-",
"system",
"metrics"
] |
[
"public",
"void",
"analyse",
"(",
"final",
"immutable",
"map",
"<",
"string",
",",
"sample",
"family",
">",
"sample",
"families",
")",
"{",
"immutable",
"map",
"<",
"string",
",",
"sample",
"family",
">",
"input",
"=",
"samples",
"stream",
"(",
")",
"map",
"(",
"s",
"-",
">",
"tuple",
"of",
"(",
"s",
",",
"sample",
"families",
"get",
"(",
"s",
")",
")",
")",
"filter",
"(",
"t",
"-",
">",
"t",
"2",
"!",
"=",
"null",
")",
"collect",
"(",
"immutable",
"map",
"to",
"immutable",
"map",
"(",
"t",
"-",
">",
"t",
"1",
",",
"t",
"-",
">",
"t",
"2",
")",
")",
";",
"if",
"(",
"input",
"size",
"(",
")",
"<",
"1",
")",
"{",
"if",
"(",
"log",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"log",
"debug",
"(",
"\"",
"{",
"}",
"is",
"ignored",
"due",
"to",
"the",
"lack",
"of",
"{",
"}",
"\"",
",",
"expression",
",",
"samples",
")",
";",
"}",
"return",
";",
"}",
"result",
"r",
"=",
"expression",
"run",
"(",
"input",
")",
";",
"if",
"(",
"!",
"r",
"is",
"success",
"(",
")",
")",
"{",
"return",
";",
"}",
"sample",
"family",
"running",
"context",
"ctx",
"=",
"r",
"get",
"data",
"(",
")",
"context",
";",
"sample",
"[",
"]",
"ss",
"=",
"r",
"get",
"data",
"(",
")",
"samples",
";",
"generate",
"traffic",
"(",
"ctx",
"get",
"meter",
"entity",
"(",
")",
")",
";",
"switch",
"(",
"metric",
"type",
")",
"{",
"case",
"single",
":",
"acceptable",
"value",
"<",
"long",
">",
"sv",
"=",
"meter",
"system",
"build",
"metrics",
"(",
"metric",
"name",
",",
"long",
"class",
")",
";",
"sv",
"accept",
"(",
"ctx",
"get",
"meter",
"entity",
"(",
")",
",",
"get",
"value",
"(",
"ss",
"[",
"0",
"]",
")",
")",
";",
"send",
"(",
"sv",
",",
"ss",
"[",
"0",
"]",
"get",
"timestamp",
"(",
")",
")",
";",
"break",
";",
"case",
"labeled",
":",
"acceptable",
"value",
"<",
"data",
"table",
">",
"lv",
"=",
"meter",
"system",
"build",
"metrics",
"(",
"metric",
"name",
",",
"data",
"table",
"class",
")",
";",
"data",
"table",
"dt",
"=",
"new",
"data",
"table",
"(",
")",
";",
"for",
"(",
"sample",
"each",
":",
"ss",
")",
"{",
"dt",
"put",
"(",
"compose",
"group",
"(",
"each",
"get",
"labels",
"(",
")",
")",
",",
"get",
"value",
"(",
"each",
")",
")",
";",
"}",
"lv",
"accept",
"(",
"ctx",
"get",
"meter",
"entity",
"(",
")",
",",
"dt",
")",
";",
"send",
"(",
"lv",
",",
"ss",
"[",
"0",
"]",
"get",
"timestamp",
"(",
")",
")",
";",
"break",
";",
"case",
"histogram",
":",
"case",
"histogram",
"percentile",
":",
"stream",
"of",
"(",
"ss",
")",
"map",
"(",
"s",
"-",
">",
"tuple",
"of",
"(",
"compose",
"group",
"(",
"s",
"get",
"labels",
"(",
")",
",",
"k",
"-",
">",
"!",
"objects",
"equals",
"(",
"\"",
"le",
"\"",
",",
"k",
")",
")",
",",
"s",
")",
")",
"collect",
"(",
"grouping",
"by",
"(",
"tuple",
"2",
":",
":",
"1",
",",
"mapping",
"(",
"tuple",
"2",
":",
":",
"2",
",",
"to",
"list",
"(",
")",
")",
")",
")",
"for",
"each",
"(",
"(",
"group",
",",
"sub",
"ss",
")",
"-",
">",
"{",
"if",
"(",
"sub",
"ss",
"size",
"(",
")",
"<",
"1",
")",
"{",
"return",
";",
"}",
"long",
"[",
"]",
"bb",
"=",
"new",
"long",
"[",
"sub",
"ss",
"size",
"(",
")",
"]",
";",
"long",
"[",
"]",
"vv",
"=",
"new",
"long",
"[",
"bb",
"length",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"sub",
"ss",
"size",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"sample",
"s",
"=",
"sub",
"ss",
"get",
"(",
"i",
")",
";",
"bb",
"[",
"i",
"]",
"=",
"long",
"parse",
"long",
"(",
"s",
"get",
"labels",
"(",
")",
"get",
"(",
"\"",
"le",
"\"",
")",
")",
";",
"vv",
"[",
"i",
"]",
"=",
"get",
"value",
"(",
"s",
")",
";",
"}",
"bucketed",
"values",
"bv",
"=",
"new",
"bucketed",
"values",
"(",
"bb",
",",
"vv",
")",
";",
"long",
"time",
"=",
"sub",
"ss",
"get",
"(",
"0",
")",
"get",
"timestamp",
"(",
")",
";",
"if",
"(",
"metric",
"type",
"=",
"=",
"metric",
"type",
"histogram",
")",
"{",
"acceptable",
"value",
"<",
"bucketed",
"values",
">",
"v",
"=",
"meter",
"system",
"build",
"metrics",
"(",
"metric",
"name",
",",
"bucketed",
"values",
"class",
")",
";",
"v",
"accept",
"(",
"ctx",
"get",
"meter",
"entity",
"(",
")",
",",
"bv",
")",
";",
"send",
"(",
"v",
",",
"time",
")",
";",
"return",
";",
"}",
"acceptable",
"value",
"<",
"percentile",
"argument",
">",
"v",
"=",
"meter",
"system",
"build",
"metrics",
"(",
"metric",
"name",
",",
"percentile",
"argument",
"class",
")",
";",
"v",
"accept",
"(",
"ctx",
"get",
"meter",
"entity",
"(",
")",
",",
"new",
"percentile",
"argument",
"(",
"bv",
",",
"percentiles",
")",
")",
";",
"send",
"(",
"v",
",",
"time",
")",
";",
"}",
")",
";",
"break",
";",
"}",
"}"
] |
[
"check",
"if",
"the",
"given",
"{",
"@",
"code",
"string",
"}",
"is",
"a",
"problem",
"json",
"mime",
"(",
"rfc",
"-",
"7807",
")"
] |
[
"public",
"boolean",
"is",
"problem",
"json",
"mime",
"(",
"string",
"media",
"type",
")",
"{",
"return",
"\"",
"application",
"/",
"problem",
"+",
"json",
"\"",
"equals",
"ignore",
"case",
"(",
"media",
"type",
")",
";",
"}"
] |
[
"callback",
"for",
"a",
"state",
"change",
"event",
":",
"log",
"it"
] |
[
"public",
"void",
"state",
"changed",
"(",
"service",
"service",
")",
"{",
"log",
"info",
"(",
"\"",
"entry",
"to",
"state",
"\"",
"+",
"service",
"get",
"service",
"state",
"(",
")",
"+",
"\"",
"for",
"\"",
"+",
"service",
"get",
"name",
"(",
")",
")",
";",
"}"
] |
[
"replaces",
"all",
"newline",
"characters",
"with",
"html",
"&",
"lt",
";",
"br",
"&",
"gt",
";",
"tags",
"<",
"p",
">",
"unlike",
"{",
"@",
"link",
"#",
"to",
"wrapped",
"h",
"t",
"m",
"l",
"(",
"string",
")",
"}",
",",
"this",
"method",
"does",
"<",
"b",
">",
"not",
"<",
"b",
">",
"add",
"the",
"&",
"lt",
";",
"html",
"&",
"gt",
";",
"tag",
"to",
"the",
"given",
"text",
"<",
"p",
">",
"call",
"this",
"method",
"when",
"you",
"wish",
"to",
"create",
"your",
"own",
"html",
"content",
",",
"with",
"parts",
"of",
"that",
"content",
"line",
"wrapped"
] |
[
"public",
"static",
"string",
"line",
"wrap",
"with",
"h",
"t",
"m",
"l",
"line",
"breaks",
"(",
"string",
"text",
",",
"int",
"max",
"line",
"length",
")",
"{",
"if",
"(",
"is",
"unbreakable",
"h",
"t",
"m",
"l",
"(",
"text",
")",
")",
"{",
"log",
"unbreakable",
"h",
"t",
"m",
"l",
"warning",
"(",
")",
";",
"return",
"text",
";",
"}",
"list",
"<",
"string",
">",
"lines",
"=",
"html",
"line",
"splitter",
"split",
"(",
"text",
",",
"max",
"line",
"length",
")",
";",
"string",
"builder",
"buffer",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"for",
"(",
"int",
"n",
"=",
"0",
";",
"n",
"<",
"lines",
"size",
"(",
")",
";",
"n",
"+",
"+",
")",
"{",
"string",
"line",
"=",
"lines",
"get",
"(",
"n",
")",
";",
"buffer",
"append",
"(",
"line",
")",
";",
"if",
"(",
"n",
"!",
"=",
"(",
"lines",
"size",
"(",
")",
"-",
"1",
")",
")",
"{",
"/",
"/",
"terminate",
"line",
"if",
"not",
"the",
"last",
"line",
"buffer",
"append",
"(",
"br",
")",
";",
"buffer",
"append",
"(",
"'",
"\\",
"n",
"'",
")",
";",
"}",
"}",
"return",
"buffer",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"get",
"int",
"3",
"2",
"minimum",
":",
"20",
"maximum",
":",
"200"
] |
[
"public",
"integer",
"get",
"int",
"3",
"2",
"(",
")",
"{",
"return",
"int",
"3",
"2",
";",
"}"
] |
[
"try",
"to",
"push",
"down",
"query",
"like",
":",
"`",
"select",
"count",
"(",
"distinct",
"$",
"column",
")",
"from",
"my",
"table",
"`",
"to",
"pinot",
"as",
"`",
"select",
"distinct",
"count",
"(",
"$",
"column",
")",
"from",
"my",
"table",
"`",
"this",
"function",
"only",
"handles",
"the",
"case",
"of",
"an",
"aggregation",
"node",
"(",
"count",
"on",
"$",
"column",
")",
"on",
"top",
"of",
"an",
"aggregation",
"node",
"(",
"of",
"non",
"-",
"aggregate",
"on",
"$",
"column",
")"
] |
[
"private",
"static",
"boolean",
"handle",
"push",
"down",
"single",
"distinct",
"count",
"(",
"immutable",
"list",
"builder",
"<",
"aggregation",
"column",
"node",
">",
"node",
"builder",
",",
"aggregation",
"node",
"aggregation",
"node",
",",
"variable",
"reference",
"expression",
"output",
"column",
",",
"aggregation",
"node",
"aggregation",
"aggregation",
")",
"{",
"if",
"(",
"!",
"aggregation",
"get",
"call",
"(",
")",
"get",
"display",
"name",
"(",
")",
"equals",
"ignore",
"case",
"(",
"count",
"function",
"name",
")",
")",
"{",
"return",
"false",
";",
"}",
"list",
"<",
"row",
"expression",
">",
"arguments",
"=",
"aggregation",
"get",
"call",
"(",
")",
"get",
"arguments",
"(",
")",
";",
"if",
"(",
"arguments",
"size",
"(",
")",
"!",
"=",
"1",
")",
"{",
"return",
"false",
";",
"}",
"row",
"expression",
"aggregation",
"argument",
"=",
"arguments",
"get",
"(",
"0",
")",
";",
"/",
"/",
"handle",
"the",
"case",
"of",
"count",
"aggregation",
"on",
"top",
"of",
"a",
"non",
"-",
"agg",
"group",
"by",
"aggregation",
"if",
"(",
"!",
"(",
"aggregation",
"node",
"get",
"source",
"(",
")",
"instanceof",
"aggregation",
"node",
")",
")",
"{",
"return",
"false",
";",
"}",
"aggregation",
"node",
"source",
"aggregation",
"node",
"=",
"(",
"aggregation",
"node",
")",
"aggregation",
"node",
"get",
"source",
"(",
")",
";",
"set",
"<",
"string",
">",
"source",
"aggregation",
"group",
"set",
"=",
"get",
"group",
"keys",
"(",
"source",
"aggregation",
"node",
"get",
"grouping",
"keys",
"(",
")",
")",
";",
"set",
"<",
"string",
">",
"aggregation",
"group",
"set",
"=",
"get",
"group",
"keys",
"(",
"aggregation",
"node",
"get",
"grouping",
"keys",
"(",
")",
")",
";",
"aggregation",
"group",
"set",
"add",
"(",
"aggregation",
"argument",
"to",
"string",
"(",
")",
")",
";",
"if",
"(",
"!",
"source",
"aggregation",
"group",
"set",
"contains",
"all",
"(",
"aggregation",
"group",
"set",
")",
"&",
"&",
"aggregation",
"group",
"set",
"contains",
"all",
"(",
"source",
"aggregation",
"group",
"set",
")",
")",
"{",
"return",
"false",
";",
"}",
"node",
"builder",
"add",
"(",
"new",
"aggregation",
"function",
"column",
"node",
"(",
"output",
"column",
",",
"new",
"call",
"expression",
"(",
"pinot",
"distinct",
"count",
"function",
"name",
",",
"aggregation",
"get",
"function",
"handle",
"(",
")",
",",
"aggregation",
"get",
"call",
"(",
")",
"get",
"type",
"(",
")",
",",
"immutable",
"list",
"of",
"(",
"aggregation",
"argument",
")",
")",
")",
")",
";",
"return",
"true",
";",
"}"
] |
[
"returns",
"all",
"nodes",
"in",
"this",
"graph",
"adjacent",
"to",
"{",
"@",
"code",
"node",
"}",
"which",
"can",
"be",
"reached",
"by",
"traversing",
"{",
"@",
"code",
"node",
"}",
"'",
"s",
"outgoing",
"edges",
"in",
"the",
"direction",
"(",
"if",
"any",
")",
"of",
"the",
"edge",
"in",
"an",
"undirected",
"graph",
",",
"this",
"is",
"equivalent",
"to",
"{",
"@",
"link",
"#",
"adjacent",
"nodes",
"(",
"object",
")",
"}",
"this",
"is",
"not",
"the",
"same",
"as",
"\"",
"all",
"nodes",
"reachable",
"from",
"{",
"@",
"code",
"node",
"}",
"by",
"following",
"outgoing",
"edges",
"\"",
"for",
"that",
"functionality",
",",
"see",
"{",
"@",
"link",
"graphs",
"#",
"reachable",
"nodes",
"(",
"graph",
",",
"object",
")",
"}"
] |
[
"set",
"<",
"n",
">",
"successors",
"(",
"n",
"node",
")",
";"
] |
[
"returns",
"true",
"if",
"and",
"only",
"if",
"this",
"operator",
"can",
"accept",
"an",
"input",
"page"
] |
[
"boolean",
"needs",
"input",
"(",
")",
";"
] |
[
"collect",
"all",
"the",
"symbols",
"for",
"a",
"particular",
"symbol",
"type",
"to",
"a",
"sorted",
"list",
"of",
"symbols",
"the",
"symbols",
"are",
"sorted",
"by",
"name",
"to",
"make",
"output",
"predicable",
"and",
",",
"therefore",
",",
"testing",
"easier"
] |
[
"private",
"static",
"list",
"<",
"symbol",
">",
"get",
"symbol",
"by",
"resource",
"type",
"(",
"@",
"non",
"null",
"symbol",
"table",
"table",
",",
"@",
"non",
"null",
"resource",
"type",
"type",
")",
"{",
"final",
"comparator",
"<",
"symbol",
">",
"name",
"comparator",
"=",
"comparator",
"comparing",
"(",
"symbol",
":",
":",
"get",
"name",
")",
";",
"final",
"immutable",
"collection",
"<",
"symbol",
">",
"symbol",
"collection",
"=",
"table",
"get",
"symbols",
"(",
")",
"row",
"(",
"type",
")",
"values",
"(",
")",
";",
"list",
"<",
"symbol",
">",
"symbols",
"=",
"lists",
"new",
"array",
"list",
"(",
"symbol",
"collection",
")",
";",
"symbols",
"sort",
"(",
"name",
"comparator",
")",
";",
"return",
"symbols",
";",
"}"
] |
[
"return",
"the",
"string",
"value",
"in",
"sp"
] |
[
"public",
"static",
"string",
"get",
"string",
"(",
"@",
"non",
"null",
"final",
"string",
"key",
",",
"@",
"non",
"null",
"final",
"s",
"p",
"utils",
"sp",
"utils",
")",
"{",
"return",
"sp",
"utils",
"get",
"string",
"(",
"key",
")",
";",
"}"
] |
[
"confirm",
"that",
"one",
"of",
"the",
"assembly",
"results",
"matches",
"the",
"pattern",
"described",
"by",
"instr"
] |
[
"protected",
"void",
"check",
"one",
"compat",
"(",
"string",
"instr",
",",
"assembly",
"resolution",
"results",
"rr",
")",
"{",
"assembly",
"pattern",
"block",
"ins",
"=",
"assembly",
"pattern",
"block",
"from",
"string",
"(",
"instr",
")",
";",
"dbg",
"println",
"(",
"\"",
"checking",
"against",
":",
"\"",
"+",
"ins",
")",
";",
"set",
"<",
"assembly",
"resolved",
"error",
">",
"errs",
"=",
"new",
"tree",
"set",
"<",
">",
"(",
")",
";",
"/",
"/",
"display",
"in",
"order",
",",
"i",
"guess",
"set",
"<",
"assembly",
"resolved",
"constructor",
">",
"misses",
"=",
"new",
"tree",
"set",
"<",
">",
"(",
")",
";",
"for",
"(",
"assembly",
"resolution",
"ar",
":",
"rr",
")",
"{",
"if",
"(",
"ar",
"is",
"error",
"(",
")",
")",
"{",
"errs",
"add",
"(",
"(",
"assembly",
"resolved",
"error",
")",
"ar",
")",
";",
"continue",
";",
"}",
"assembly",
"resolved",
"constructor",
"rescon",
"=",
"(",
"assembly",
"resolved",
"constructor",
")",
"ar",
";",
"if",
"(",
"ins",
"get",
"vals",
"(",
")",
"length",
"=",
"=",
"rescon",
"get",
"instruction",
"length",
"(",
")",
"&",
"&",
"ins",
"combine",
"(",
"rescon",
"get",
"instruction",
"(",
")",
")",
"!",
"=",
"null",
")",
"{",
"return",
";",
"}",
"misses",
"add",
"(",
"rescon",
")",
";",
"}",
"dbg",
"println",
"(",
"\"",
"errors",
":",
"\"",
")",
";",
"for",
"(",
"assembly",
"resolution",
"ar",
":",
"errs",
")",
"{",
"dbg",
"println",
"(",
"ar",
"to",
"string",
"(",
"\"",
"\"",
")",
")",
";",
"}",
"dbg",
"println",
"(",
"\"",
"mismatches",
":",
"\"",
")",
";",
"for",
"(",
"assembly",
"resolution",
"ar",
":",
"misses",
")",
"{",
"dbg",
"println",
"(",
"ar",
"to",
"string",
"(",
"\"",
"\"",
")",
")",
";",
"}",
"fail",
"(",
"\"",
"no",
"result",
"matched",
"the",
"desired",
"instruction",
"bytes",
"\"",
")",
";",
"}"
] |
[
"this",
"is",
"the",
"<",
"a",
"href",
"=",
"\"",
"https",
":",
"tools",
"ietf",
"orghtmlrfc",
"7",
"5",
"4",
"0",
"#",
"section",
"-",
"6",
"5",
"2",
"\"",
">",
"settings",
"enable",
"push",
"value",
"sent",
"from",
"the",
"opposite",
"endpoint",
"the",
"initial",
"value",
"must",
"be",
"{",
"@",
"code",
"true",
"}",
"for",
"the",
"client",
"endpoint",
"and",
"always",
"false",
"for",
"a",
"server",
"endpoint"
] |
[
"boolean",
"allow",
"push",
"to",
"(",
")",
";"
] |
[
"called",
"to",
"report",
"successful",
"receipt",
"of",
"server",
"config"
] |
[
"void",
"on",
"success",
"(",
"downstream",
"tls",
"context",
"downstream",
"tls",
"context",
")",
";"
] |
[
"return",
"true",
"if",
"-",
"a",
"reconfiguration",
"task",
"has",
"finished",
"or",
"-",
"an",
"active",
"reconfiguration",
"task",
"is",
"running"
] |
[
"public",
"boolean",
"has",
"task",
"(",
")",
"{",
"return",
"start",
"time",
">",
"0",
";",
"}"
] |
[
"returns",
"all",
"arguments",
",",
"including",
"ones",
"inside",
"of",
"param",
"files",
"suitable",
"for",
"debugging",
"and",
"printing",
"messages",
"to",
"users",
"this",
"expands",
"all",
"command",
"lines",
",",
"so",
"it",
"is",
"potentially",
"expensive"
] |
[
"public",
"immutable",
"list",
"<",
"string",
">",
"all",
"arguments",
"(",
")",
"throws",
"command",
"line",
"expansion",
"exception",
",",
"interrupted",
"exception",
"{",
"immutable",
"list",
"builder",
"<",
"string",
">",
"arguments",
"=",
"immutable",
"list",
"builder",
"(",
")",
";",
"for",
"(",
"command",
"line",
"and",
"param",
"file",
"info",
"pair",
":",
"get",
"command",
"lines",
"(",
")",
")",
"{",
"arguments",
"add",
"all",
"(",
"pair",
"command",
"line",
"arguments",
"(",
")",
")",
";",
"}",
"return",
"arguments",
"build",
"(",
")",
";",
"}"
] |
[
"evaluate",
"the",
"positions",
"of",
"the",
"vertices",
"depending",
"on",
"policy"
] |
[
"boolean",
"evaluate",
"(",
"quaternion",
"[",
"]",
"vertices",
")",
"{",
"switch",
"(",
"this",
")",
"{",
"case",
"draw",
":",
"return",
"false",
";",
"case",
"query",
":",
"/",
"/",
"if",
"we",
"are",
"querying",
"and",
"any",
"of",
"the",
"vertices",
"are",
"behind",
"the",
"camera",
",",
"return",
"true",
"/",
"/",
"this",
"means",
"a",
"bounding",
"box",
"will",
"not",
"be",
"considered",
"occluded",
"when",
"any",
"of",
"its",
"vertices",
"/",
"/",
"are",
"behind",
"the",
"camera",
"frustum",
"near",
"plane",
"for",
"(",
"quaternion",
"vertex",
":",
"vertices",
")",
"{",
"if",
"(",
"vertex",
"z",
"+",
"vertex",
"w",
"<",
"=",
"0",
")",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"return",
"false",
";",
"}"
] |
[
"get",
"user",
"{",
"username",
"}",
":",
"get",
"user",
"by",
"user",
"name"
] |
[
"default",
"mono",
"<",
"response",
"entity",
"<",
"user",
">",
">",
"get",
"user",
"by",
"name",
"(",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"the",
"name",
"that",
"needs",
"to",
"be",
"fetched",
"use",
"user",
"1",
"for",
"testing",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"path",
"variable",
"(",
"\"",
"username",
"\"",
")",
"string",
"username",
",",
"@",
"api",
"ignore",
"final",
"server",
"web",
"exchange",
"exchange",
")",
"{",
"return",
"get",
"delegate",
"(",
")",
"get",
"user",
"by",
"name",
"(",
"username",
",",
"exchange",
")",
";",
"}"
] |
[
"encodes",
"the",
"an",
"integer",
"as",
"a",
"string",
"with",
"given",
"radix",
",",
"then",
"uses",
"{",
"@",
"link",
"ints",
"#",
"try",
"parse",
"(",
"string",
",",
"int",
")",
"}",
"to",
"parse",
"the",
"result",
"asserts",
"the",
"result",
"is",
"the",
"same",
"as",
"what",
"we",
"started",
"with"
] |
[
"private",
"static",
"void",
"radix",
"encode",
"parse",
"and",
"assert",
"equals",
"(",
"integer",
"value",
",",
"int",
"radix",
")",
"{",
"assert",
"equals",
"(",
"\"",
"radix",
":",
"\"",
"+",
"radix",
",",
"value",
",",
"ints",
"try",
"parse",
"(",
"integer",
"to",
"string",
"(",
"value",
",",
"radix",
")",
",",
"radix",
")",
")",
";",
"}"
] |
[
"a",
"helper",
"api",
"for",
"creating",
"an",
"audit",
"log",
"for",
"a",
"failure",
"event"
] |
[
"static",
"string",
"create",
"failure",
"log",
"(",
"string",
"user",
",",
"string",
"operation",
",",
"string",
"perm",
",",
"string",
"target",
",",
"string",
"description",
",",
"application",
"id",
"app",
"id",
",",
"application",
"attempt",
"id",
"attempt",
"id",
",",
"container",
"id",
"container",
"id",
",",
"resource",
"resource",
")",
"{",
"return",
"create",
"failure",
"log",
"(",
"user",
",",
"operation",
",",
"perm",
",",
"target",
",",
"description",
",",
"app",
"id",
",",
"attempt",
"id",
",",
"container",
"id",
",",
"resource",
",",
"null",
",",
"null",
",",
"null",
")",
";",
"}"
] |
[
"it",
"store",
"real",
"value",
"when",
"type",
"is",
"primitive",
"it",
"store",
"the",
"length",
"and",
"offset",
"of",
"variable",
"-",
"length",
"part",
"when",
"type",
"is",
"string",
",",
"map",
",",
"etc"
] |
[
"public",
"static",
"int",
"calculate",
"fix",
"length",
"part",
"size",
"(",
"logical",
"type",
"type",
")",
"{",
"/",
"/",
"ordered",
"by",
"type",
"root",
"definition",
"switch",
"(",
"type",
"get",
"type",
"root",
"(",
")",
")",
"{",
"case",
"boolean",
":",
"case",
"tinyint",
":",
"return",
"1",
";",
"case",
"char",
":",
"case",
"varchar",
":",
"case",
"binary",
":",
"case",
"varbinary",
":",
"case",
"decimal",
":",
"case",
"bigint",
":",
"case",
"double",
":",
"case",
"timestamp",
"without",
"time",
"zone",
":",
"case",
"timestamp",
"with",
"local",
"time",
"zone",
":",
"case",
"interval",
"day",
"time",
":",
"case",
"array",
":",
"case",
"multiset",
":",
"case",
"map",
":",
"case",
"row",
":",
"case",
"structured",
"type",
":",
"case",
"raw",
":",
"/",
"/",
"long",
"and",
"double",
"are",
"8",
"bytes",
";",
"/",
"/",
"otherwise",
"it",
"stores",
"the",
"length",
"and",
"offset",
"of",
"the",
"variable",
"-",
"length",
"part",
"for",
"types",
"/",
"/",
"such",
"as",
"is",
"string",
",",
"map",
",",
"etc",
"return",
"8",
";",
"case",
"timestamp",
"with",
"time",
"zone",
":",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
")",
";",
"case",
"smallint",
":",
"return",
"2",
";",
"case",
"integer",
":",
"case",
"float",
":",
"case",
"date",
":",
"case",
"time",
"without",
"time",
"zone",
":",
"case",
"interval",
"year",
"month",
":",
"return",
"4",
";",
"case",
"distinct",
"type",
":",
"return",
"calculate",
"fix",
"length",
"part",
"size",
"(",
"(",
"(",
"distinct",
"type",
")",
"type",
")",
"get",
"source",
"type",
"(",
")",
")",
";",
"case",
"null",
":",
"case",
"symbol",
":",
"case",
"unresolved",
":",
"default",
":",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
")",
";",
"}",
"}"
] |
[
"test",
"valid",
"value",
"range",
"for",
"the",
"config",
"namenode",
"maintenance",
"replication",
"min"
] |
[
"public",
"void",
"test",
"maintenance",
"min",
"repl",
"config",
"range",
"(",
")",
"{",
"log",
"info",
"(",
"\"",
"setting",
"test",
"maintenance",
"min",
"repl",
"config",
"range",
"\"",
")",
";",
"/",
"/",
"case",
"1",
":",
"maintenance",
"min",
"replication",
"less",
"allowed",
"minimum",
"0",
"set",
"min",
"maintenance",
"r",
"(",
"-",
"1",
")",
";",
"try",
"{",
"start",
"cluster",
"(",
"1",
",",
"1",
")",
";",
"fail",
"(",
"\"",
"cluster",
"start",
"should",
"fail",
"when",
"'",
"dfs",
"namenode",
"maintenance",
"\"",
"+",
"\"",
"replication",
"min",
"=",
"-",
"1",
"'",
"\"",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"log",
"info",
"(",
"\"",
"expected",
"exception",
":",
"\"",
"+",
"e",
")",
";",
"}",
"/",
"/",
"case",
"2",
":",
"maintenance",
"min",
"replication",
"greater",
"/",
"/",
"allowed",
"max",
"of",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"replication",
"key",
"int",
"default",
"repl",
"=",
"get",
"conf",
"(",
")",
"get",
"int",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"replication",
"key",
",",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"replication",
"default",
")",
";",
"set",
"min",
"maintenance",
"r",
"(",
"default",
"repl",
"+",
"1",
")",
";",
"try",
"{",
"start",
"cluster",
"(",
"1",
",",
"1",
")",
";",
"fail",
"(",
"\"",
"cluster",
"start",
"should",
"fail",
"when",
"'",
"dfs",
"namenode",
"maintenance",
"\"",
"+",
"\"",
"replication",
"min",
">",
"\"",
"+",
"default",
"repl",
"+",
"\"",
"'",
"\"",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"log",
"info",
"(",
"\"",
"expected",
"exception",
":",
"\"",
"+",
"e",
")",
";",
"}",
"}"
] |
[
"bridge",
"to",
"controller",
"method",
"-",
"level",
"annotations"
] |
[
"public",
"<",
"a",
"extends",
"annotation",
">",
"a",
"get",
"method",
"annotation",
"(",
"class",
"<",
"a",
">",
"annotation",
"type",
")",
"{",
"return",
"servlet",
"invocable",
"handler",
"method",
"this",
"get",
"method",
"annotation",
"(",
"annotation",
"type",
")",
";",
"}"
] |
[
"return",
"the",
"hex",
"string",
"of",
"sha1",
"encryption"
] |
[
"public",
"static",
"string",
"encrypt",
"s",
"h",
"a",
"1",
"to",
"string",
"(",
"final",
"byte",
"[",
"]",
"data",
")",
"{",
"return",
"utils",
"bridge",
"bytes",
"2",
"hex",
"string",
"(",
"encrypt",
"s",
"h",
"a",
"1",
"(",
"data",
")",
")",
";",
"}"
] |
[
"each",
"realm",
"can",
"define",
"response",
"headers",
"to",
"be",
"sent",
"on",
"failure",
"by",
"default",
"it",
"adds",
"'",
"www",
"-",
"authenticate",
"'",
"header",
"with",
"auth",
"scheme",
"'",
"basic",
"'"
] |
[
"public",
"map",
"<",
"string",
",",
"list",
"<",
"string",
">",
">",
"get",
"authentication",
"failure",
"headers",
"(",
")",
"{",
"return",
"collections",
"singleton",
"map",
"(",
"\"",
"www",
"-",
"authenticate",
"\"",
",",
"collections",
"singleton",
"list",
"(",
"\"",
"basic",
"realm",
"=",
"\\",
"\"",
"\"",
"+",
"x",
"pack",
"field",
"security",
"+",
"\"",
"\\",
"\"",
"charset",
"=",
"\\",
"\"",
"utf",
"-",
"8",
"\\",
"\"",
"\"",
")",
")",
";",
"}"
] |
[
"set",
"the",
"{",
"@",
"link",
"#",
"size",
"(",
")",
"}",
"and",
"ensure",
"that",
"the",
"{",
"@",
"link",
"#",
"values",
"}",
"array",
"can",
"store",
"at",
"least",
"that",
"many",
"entries"
] |
[
"protected",
"void",
"resize",
"(",
"int",
"new",
"size",
")",
"{",
"count",
"=",
"new",
"size",
";",
"values",
"=",
"grow",
"(",
"values",
",",
"count",
")",
";",
"}"
] |
[
"required",
":",
"the",
"port",
"on",
"which",
"the",
"proxy",
"should",
"listen",
"for",
"incoming",
"connections",
"<",
"code",
">",
"istio",
"networking",
"v",
"1alpha",
"3",
"port",
"port",
"=",
"1",
";",
"<",
"code",
">"
] |
[
"public",
"boolean",
"has",
"port",
"(",
")",
"{",
"return",
"port",
"builder",
"!",
"=",
"null",
"|",
"|",
"port",
"!",
"=",
"null",
";",
"}"
] |
[
"sets",
"the",
"category",
"of",
"the",
"deployment",
"deployments",
"can",
"be",
"queried",
"by",
"category",
":",
"see",
"{",
"@",
"link",
"deployment",
"query",
"#",
"deployment",
"category",
"(",
"string",
")",
"}"
] |
[
"void",
"set",
"deployment",
"category",
"(",
"string",
"deployment",
"id",
",",
"string",
"category",
")",
";"
] |
[
"calculates",
"diff",
"between",
"two",
"maps",
"of",
"diffable",
"objects"
] |
[
"public",
"static",
"<",
"k",
",",
"t",
"extends",
"diffable",
"<",
"t",
">",
">",
"map",
"diff",
"<",
"k",
",",
"t",
",",
"map",
"<",
"k",
",",
"t",
">",
">",
"diff",
"(",
"map",
"<",
"k",
",",
"t",
">",
"before",
",",
"map",
"<",
"k",
",",
"t",
">",
"after",
",",
"key",
"serializer",
"<",
"k",
">",
"key",
"serializer",
")",
"{",
"assert",
"after",
"!",
"=",
"null",
"&",
"&",
"before",
"!",
"=",
"null",
";",
"return",
"new",
"jdk",
"map",
"diff",
"<",
">",
"(",
"before",
",",
"after",
",",
"key",
"serializer",
",",
"diffable",
"value",
"serializer",
"get",
"write",
"only",
"instance",
"(",
")",
")",
";",
"}"
] |
[
"combiner",
"does",
"not",
"need",
"to",
"configure"
] |
[
"public",
"void",
"configure",
"(",
"job",
"conf",
"job",
")",
"{",
"}"
] |
[
"delivers",
"the",
"given",
"operator",
"event",
"to",
"the",
"{",
"@",
"link",
"operator",
"coordinator",
"}",
"with",
"the",
"given",
"{",
"@",
"link",
"operator",
"i",
"d",
"}",
"failure",
"semantics",
":",
"if",
"the",
"task",
"manager",
"sends",
"an",
"event",
"for",
"a",
"non",
"-",
"running",
"task",
"or",
"a",
"non",
"-",
"existing",
"operator",
"coordinator",
",",
"then",
"respond",
"with",
"an",
"exception",
"to",
"the",
"call",
"if",
"task",
"and",
"coordinator",
"exist",
",",
"then",
"we",
"assume",
"that",
"the",
"call",
"from",
"the",
"task",
"manager",
"was",
"valid",
",",
"and",
"any",
"bubbling",
"exception",
"needs",
"to",
"cause",
"a",
"job",
"failure"
] |
[
"void",
"deliver",
"operator",
"event",
"to",
"coordinator",
"(",
"execution",
"attempt",
"i",
"d",
"task",
"execution",
",",
"operator",
"i",
"d",
"operator",
",",
"operator",
"event",
"evt",
")",
"throws",
"flink",
"exception",
";"
] |
[
"asserts",
"correct",
"reading",
"of",
"standard",
"test",
"data",
"from",
"{",
"@",
"code",
"sample",
"queue",
"}"
] |
[
"private",
"void",
"assert",
"read",
"test",
"data",
"(",
"format",
"start",
"format",
",",
"int",
"first",
"sample",
"index",
",",
"int",
"sample",
"count",
",",
"long",
"sample",
"offset",
"us",
",",
"long",
"decode",
"only",
"until",
"us",
")",
"{",
"format",
"format",
"=",
"adjust",
"format",
"(",
"start",
"format",
",",
"sample",
"offset",
"us",
")",
";",
"for",
"(",
"int",
"i",
"=",
"first",
"sample",
"index",
";",
"i",
"<",
"first",
"sample",
"index",
"+",
"sample",
"count",
";",
"i",
"+",
"+",
")",
"{",
"/",
"/",
"use",
"equals",
"(",
")",
"on",
"the",
"read",
"side",
"despite",
"using",
"referential",
"equality",
"on",
"the",
"write",
"side",
",",
"since",
"/",
"/",
"sample",
"queue",
"de",
"-",
"duplicates",
"written",
"formats",
"using",
"equals",
"(",
")",
"format",
"test",
"sample",
"format",
"=",
"adjust",
"format",
"(",
"sample",
"formats",
"[",
"i",
"]",
",",
"sample",
"offset",
"us",
")",
";",
"if",
"(",
"!",
"test",
"sample",
"format",
"equals",
"(",
"format",
")",
")",
"{",
"/",
"/",
"if",
"the",
"format",
"has",
"changed",
",",
"we",
"should",
"read",
"it",
"assert",
"read",
"format",
"(",
"false",
",",
"test",
"sample",
"format",
")",
";",
"format",
"=",
"test",
"sample",
"format",
";",
"}",
"/",
"/",
"if",
"we",
"require",
"the",
"format",
",",
"we",
"should",
"always",
"read",
"it",
"assert",
"read",
"format",
"(",
"true",
",",
"test",
"sample",
"format",
")",
";",
"/",
"/",
"assert",
"the",
"sample",
"is",
"as",
"expected",
"long",
"expected",
"time",
"us",
"=",
"sample",
"timestamps",
"[",
"i",
"]",
"+",
"sample",
"offset",
"us",
";",
"assert",
"read",
"sample",
"(",
"expected",
"time",
"us",
",",
"(",
"sample",
"flags",
"[",
"i",
"]",
"&",
"c",
"buffer",
"flag",
"key",
"frame",
")",
"!",
"=",
"0",
",",
"/",
"*",
"is",
"decode",
"only",
"=",
"*",
"/",
"expected",
"time",
"us",
"<",
"decode",
"only",
"until",
"us",
",",
"/",
"*",
"is",
"encrypted",
"=",
"*",
"/",
"false",
",",
"data",
",",
"data",
"length",
"-",
"sample",
"offsets",
"[",
"i",
"]",
"-",
"sample",
"sizes",
"[",
"i",
"]",
",",
"sample",
"sizes",
"[",
"i",
"]",
")",
";",
"}",
"}"
] |
[
"get",
"the",
"input",
"split",
"for",
"this",
"map"
] |
[
"public",
"input",
"split",
"get",
"input",
"split",
"(",
")",
";"
] |
[
"returns",
"the",
"default",
"value",
"as",
"a",
"string",
"for",
"the",
"given",
"option"
] |
[
"public",
"abstract",
"string",
"get",
"default",
"value",
"as",
"string",
"(",
"string",
"option",
"name",
")",
";"
] |
[
"only",
"keep",
"properties",
"in",
"{",
"@",
"code",
"map",
"}",
"that",
"match",
"the",
"{",
"@",
"code",
"includes",
"}",
"but",
"not",
"the",
"{",
"@",
"code",
"excludes",
"}",
"an",
"empty",
"list",
"of",
"includes",
"is",
"interpreted",
"as",
"a",
"wildcard",
"while",
"an",
"empty",
"list",
"of",
"excludes",
"does",
"not",
"match",
"anything",
"if",
"a",
"property",
"matches",
"both",
"an",
"include",
"and",
"an",
"exclude",
",",
"then",
"the",
"exclude",
"wins",
"if",
"an",
"object",
"matches",
",",
"then",
"any",
"of",
"its",
"sub",
"properties",
"are",
"automatically",
"considered",
"as",
"matching",
"as",
"well",
",",
"both",
"for",
"includes",
"and",
"excludes",
"dots",
"in",
"field",
"names",
"are",
"treated",
"as",
"sub",
"objects",
"so",
"for",
"instance",
"if",
"a",
"document",
"contains",
"{",
"@",
"code",
"a",
"b",
"}",
"as",
"a",
"property",
"and",
"{",
"@",
"code",
"a",
"}",
"is",
"an",
"include",
",",
"then",
"{",
"@",
"code",
"a",
"b",
"}",
"will",
"be",
"kept",
"in",
"the",
"filtered",
"map"
] |
[
"public",
"static",
"map",
"<",
"string",
",",
"object",
">",
"filter",
"(",
"map",
"<",
"string",
",",
"?",
">",
"map",
",",
"string",
"[",
"]",
"includes",
",",
"string",
"[",
"]",
"excludes",
")",
"{",
"return",
"filter",
"(",
"includes",
",",
"excludes",
")",
"apply",
"(",
"map",
")",
";",
"}"
] |
[
"returns",
"true",
"if",
"the",
"list",
"in",
"this",
"panel",
"has",
"any",
"list",
"items",
"selected"
] |
[
"protected",
"boolean",
"has",
"selection",
"(",
")",
"{",
"return",
"table",
"get",
"selected",
"row",
"count",
"(",
")",
"!",
"=",
"0",
";",
"}"
] |
[
"return",
"whether",
"the",
"cookie",
"is",
"supposed",
"to",
"be",
"marked",
"with",
"the",
"\"",
"http",
"only",
"\"",
"attribute"
] |
[
"public",
"boolean",
"is",
"cookie",
"http",
"only",
"(",
")",
"{",
"return",
"this",
"cookie",
"http",
"only",
";",
"}"
] |
[
"fails",
"with",
"message",
"\"",
"should",
"throw",
"\"",
"+",
"exception",
"name"
] |
[
"public",
"void",
"should",
"throw",
"(",
"string",
"exception",
"name",
")",
"{",
"fail",
"(",
"\"",
"should",
"throw",
"\"",
"+",
"exception",
"name",
")",
";",
"}"
] |
[
"checks",
"if",
"the",
"token",
"can",
"be",
"refreshed",
"once",
"more",
"if",
"a",
"token",
"has",
"previously",
"been",
"refreshed",
",",
"it",
"can",
"only",
"by",
"refreshed",
"again",
"inside",
"a",
"short",
"span",
"of",
"time",
"(",
"30",
"s",
")"
] |
[
"private",
"static",
"optional",
"<",
"elasticsearch",
"security",
"exception",
">",
"check",
"multiple",
"refreshes",
"(",
"instant",
"refresh",
"requested",
",",
"refresh",
"token",
"status",
"refresh",
"token",
"status",
")",
"{",
"if",
"(",
"refresh",
"token",
"status",
"is",
"refreshed",
"(",
")",
")",
"{",
"if",
"(",
"refresh",
"token",
"status",
"get",
"version",
"(",
")",
"on",
"or",
"after",
"(",
"version",
"multiple",
"concurrent",
"refreshes",
")",
")",
"{",
"if",
"(",
"refresh",
"requested",
"is",
"after",
"(",
"refresh",
"token",
"status",
"get",
"refresh",
"instant",
"(",
")",
"plus",
"(",
"30l",
",",
"chrono",
"unit",
"seconds",
")",
")",
")",
"{",
"return",
"optional",
"of",
"(",
"invalid",
"grant",
"exception",
"(",
"\"",
"token",
"has",
"already",
"been",
"refreshed",
"more",
"than",
"30",
"seconds",
"in",
"the",
"past",
"\"",
")",
")",
";",
"}",
"if",
"(",
"refresh",
"requested",
"is",
"before",
"(",
"refresh",
"token",
"status",
"get",
"refresh",
"instant",
"(",
")",
"minus",
"(",
"30l",
",",
"chrono",
"unit",
"seconds",
")",
")",
")",
"{",
"return",
"optional",
"of",
"(",
"invalid",
"grant",
"exception",
"(",
"\"",
"token",
"has",
"been",
"refreshed",
"more",
"than",
"30",
"seconds",
"in",
"the",
"future",
",",
"clock",
"skew",
"too",
"great",
"\"",
")",
")",
";",
"}",
"}",
"else",
"{",
"return",
"optional",
"of",
"(",
"invalid",
"grant",
"exception",
"(",
"\"",
"token",
"has",
"already",
"been",
"refreshed",
"\"",
")",
")",
";",
"}",
"}",
"return",
"optional",
"empty",
"(",
")",
";",
"}"
] |
[
"uploads",
"an",
"image"
] |
[
"public",
"api",
"response",
"<",
"model",
"api",
"response",
">",
"upload",
"file",
"with",
"http",
"info",
"(",
"long",
"pet",
"id",
",",
"string",
"additional",
"metadata",
",",
"file",
"file",
")",
"throws",
"api",
"exception",
"{",
"http",
"request",
"builder",
"local",
"var",
"request",
"builder",
"=",
"upload",
"file",
"request",
"builder",
"(",
"pet",
"id",
",",
"additional",
"metadata",
",",
"file",
")",
";",
"try",
"{",
"http",
"response",
"<",
"input",
"stream",
">",
"local",
"var",
"response",
"=",
"member",
"var",
"http",
"client",
"send",
"(",
"local",
"var",
"request",
"builder",
"build",
"(",
")",
",",
"http",
"response",
"body",
"handlers",
"of",
"input",
"stream",
"(",
")",
")",
";",
"if",
"(",
"member",
"var",
"response",
"interceptor",
"!",
"=",
"null",
")",
"{",
"member",
"var",
"response",
"interceptor",
"accept",
"(",
"local",
"var",
"response",
")",
";",
"}",
"if",
"(",
"local",
"var",
"response",
"status",
"code",
"(",
")",
"/",
"100",
"!",
"=",
"2",
")",
"{",
"throw",
"new",
"api",
"exception",
"(",
"local",
"var",
"response",
"status",
"code",
"(",
")",
",",
"\"",
"upload",
"file",
"call",
"received",
"non",
"-",
"success",
"response",
"\"",
",",
"local",
"var",
"response",
"headers",
"(",
")",
",",
"local",
"var",
"response",
"body",
"(",
")",
"=",
"=",
"null",
"?",
"null",
":",
"new",
"string",
"(",
"local",
"var",
"response",
"body",
"(",
")",
"read",
"all",
"bytes",
"(",
")",
")",
")",
";",
"}",
"return",
"new",
"api",
"response",
"<",
"model",
"api",
"response",
">",
"(",
"local",
"var",
"response",
"status",
"code",
"(",
")",
",",
"local",
"var",
"response",
"headers",
"(",
")",
"map",
"(",
")",
",",
"member",
"var",
"object",
"mapper",
"read",
"value",
"(",
"local",
"var",
"response",
"body",
"(",
")",
",",
"new",
"type",
"reference",
"<",
"model",
"api",
"response",
">",
"(",
")",
"{",
"}",
")",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"throw",
"new",
"api",
"exception",
"(",
"e",
")",
";",
"}",
"catch",
"(",
"interrupted",
"exception",
"e",
")",
"{",
"thread",
"current",
"thread",
"(",
")",
"interrupt",
"(",
")",
";",
"throw",
"new",
"api",
"exception",
"(",
"e",
")",
";",
"}",
"}"
] |
[
"get",
"the",
"value",
"out",
"of",
"a",
"value",
"type"
] |
[
"protected",
"abstract",
"pt",
"get",
"value",
"(",
"vt",
"value",
")",
";",
"/",
"/",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"/",
"/",
"implementations",
"below",
"/",
"/",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-"
] |
[
"should",
"duplicates",
"be",
"filtered",
"or",
"not",
"defaults",
"to",
"{",
"@",
"code",
"false",
"}"
] |
[
"public",
"completion",
"suggestion",
"builder",
"skip",
"duplicates",
"(",
"boolean",
"skip",
"duplicates",
")",
"{",
"this",
"skip",
"duplicates",
"=",
"skip",
"duplicates",
";",
"return",
"this",
";",
"}"
] |
[
"peek",
"at",
"the",
"next",
"value",
"in",
"the",
"iterator",
"calling",
"this",
"method",
"multiple",
"times",
"will",
"return",
"the",
"same",
"element",
"without",
"advancing",
"this",
"iterator",
"the",
"value",
"returned",
"by",
"this",
"method",
"will",
"be",
"the",
"next",
"item",
"returned",
"by",
"{",
"@",
"code",
"next",
"(",
")",
"}"
] |
[
"public",
"t",
"peek",
"(",
")",
"{",
"return",
"next",
"value",
";",
"}"
] |
[
"creates",
"list",
"of",
"users",
"with",
"given",
"input",
"array",
"<",
"b",
">",
"0",
"<",
"b",
">",
"-",
"successful",
"operation"
] |
[
"public",
"void",
"create",
"users",
"with",
"array",
"input",
"(",
"list",
"<",
"user",
">",
"body",
")",
"throws",
"rest",
"client",
"exception",
"{",
"create",
"users",
"with",
"array",
"input",
"with",
"http",
"info",
"(",
"body",
")",
";",
"}"
] |
[
"change",
"connection",
"auto",
"commit",
"to",
"false",
"by",
"seata"
] |
[
"public",
"void",
"change",
"auto",
"commit",
"(",
")",
"throws",
"s",
"q",
"l",
"exception",
"{",
"get",
"context",
"(",
")",
"set",
"auto",
"commit",
"changed",
"(",
"true",
")",
";",
"set",
"auto",
"commit",
"(",
"false",
")",
";",
"}"
] |
[
"called",
"when",
"the",
"renderer",
"is",
"disabled"
] |
[
"default",
"void",
"on",
"video",
"disabled",
"(",
"decoder",
"counters",
"counters",
")",
"{",
"}"
] |
[
"get",
"the",
"{",
"@",
"link",
"credentials",
"provider",
"}",
"that",
"will",
"be",
"added",
"to",
"the",
"http",
"client"
] |
[
"credentials",
"provider",
"get",
"credentials",
"provider",
"(",
")",
"{",
"return",
"credentials",
"provider",
";",
"}"
] |
[
"data",
"input",
"interface"
] |
[
"public",
"void",
"read",
"fully",
"(",
"byte",
"[",
"]",
"b",
")",
"throws",
"i",
"o",
"exception",
"{",
"read",
"fully",
"(",
"b",
",",
"0",
",",
"b",
"length",
")",
";",
"}"
] |
[
"returns",
"the",
"provider",
"used",
"to",
"obtain",
"instances",
"for",
"the",
"given",
"injection",
"type",
"the",
"returned",
"provider",
"will",
"not",
"be",
"valid",
"until",
"the",
"{",
"@",
"link",
"injector",
"}",
"has",
"been",
"created",
"the",
"provider",
"will",
"throw",
"an",
"{",
"@",
"code",
"illegal",
"state",
"exception",
"}",
"if",
"you",
"try",
"to",
"use",
"it",
"beforehand"
] |
[
"<",
"t",
">",
"provider",
"<",
"t",
">",
"get",
"provider",
"(",
"class",
"<",
"t",
">",
"type",
")",
";"
] |
[
"get",
"anytype",
"3"
] |
[
"public",
"object",
"get",
"anytype",
"3",
"(",
")",
"{",
"return",
"anytype",
"3",
";",
"}"
] |
[
"get",
"the",
"accumulation",
"of",
"totally",
"allocated",
"resources",
"to",
"a",
"container"
] |
[
"public",
"resource",
"utilization",
"get",
"current",
"utilization",
"(",
")",
"{",
"return",
"this",
"containers",
"allocation",
";",
"}"
] |
[
"print",
"if",
"log",
"error",
"level",
"is",
"enabled"
] |
[
"public",
"static",
"void",
"print",
"if",
"error",
"enabled",
"(",
"logger",
"logger",
",",
"string",
"s",
",",
"object",
"args",
")",
"{",
"if",
"(",
"logger",
"is",
"error",
"enabled",
"(",
")",
")",
"{",
"logger",
"error",
"(",
"s",
",",
"args",
")",
";",
"}",
"}"
] |
[
"compares",
"two",
"float",
"writables"
] |
[
"public",
"int",
"compare",
"to",
"(",
"float",
"writable",
"o",
")",
"{",
"return",
"float",
"compare",
"(",
"value",
",",
"o",
"value",
")",
";",
"}"
] |
[
"query",
"given",
"sql",
"to",
"create",
"a",
"prepared",
"statement",
"from",
"sql",
"and",
"a",
"list",
"of",
"arguments",
"to",
"bind",
"to",
"the",
"query",
",",
"expecting",
"a",
"result",
"list",
"the",
"results",
"will",
"be",
"mapped",
"to",
"a",
"list",
"(",
"one",
"entry",
"for",
"each",
"row",
")",
"of",
"maps",
"(",
"one",
"entry",
"for",
"each",
"column",
",",
"using",
"the",
"column",
"name",
"as",
"the",
"key",
")",
"each",
"element",
"in",
"the",
"list",
"will",
"be",
"of",
"the",
"form",
"returned",
"by",
"this",
"interface",
"'",
"s",
"{",
"@",
"code",
"query",
"for",
"map",
"}",
"methods"
] |
[
"list",
"<",
"map",
"<",
"string",
",",
"object",
">",
">",
"query",
"for",
"list",
"(",
"string",
"sql",
",",
"@",
"nullable",
"object",
"args",
")",
"throws",
"data",
"access",
"exception",
";"
] |
[
"interns",
"a",
"string"
] |
[
"public",
"static",
"final",
"string",
"intern",
"(",
"string",
"arg",
")",
"{",
"return",
"interner",
"intern",
"(",
"arg",
")",
";",
"}"
] |
[
"returns",
"an",
"iterator",
"postioned",
"at",
"the",
"item",
"in",
"the",
"vector",
"that",
"is",
"the",
"smallest",
"key",
"less",
"or",
"equal",
"than",
"the",
"given",
"key",
"this",
"method",
"assumes",
"the",
"vector",
"is",
"sorted",
"in",
"ascending",
"order"
] |
[
"public",
"iterator",
"s",
"t",
"l",
"<",
"t",
">",
"lower",
"bound",
"(",
"t",
"key",
")",
"{",
"if",
"(",
"!",
"(",
"key",
"instanceof",
"comparable",
")",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
"\"",
"t",
"must",
"be",
"comparable",
"\"",
")",
";",
"}",
"return",
"lower",
"bound",
"(",
"key",
",",
"comparable",
"comparator",
")",
";",
"}"
] |
[
"compute",
"a",
"new",
"layout",
"with",
"the",
"given",
"component",
"root",
"and",
"sizes"
] |
[
"public",
"void",
"set",
"root",
"and",
"size",
"spec",
"(",
"component",
"root",
",",
"int",
"width",
"spec",
",",
"int",
"height",
"spec",
")",
"{",
"if",
"(",
"root",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"root",
"component",
"can",
"'",
"t",
"be",
"null",
"\"",
")",
";",
"}",
"set",
"root",
"and",
"size",
"spec",
"and",
"wrapper",
"(",
"root",
",",
"width",
"spec",
",",
"height",
"spec",
",",
"false",
"/",
"*",
"is",
"async",
"*",
"/",
",",
"null",
"/",
"*",
"output",
"*",
"/",
",",
"calculate",
"layout",
"source",
"set",
"root",
"sync",
",",
"-",
"1",
",",
"null",
",",
"null",
")",
";",
"}"
] |
[
"returns",
"and",
"{",
"@",
"link",
"exact",
"}",
"object",
"with",
"all",
"the",
"necessary",
"info",
"about",
"the",
"field",
":",
"if",
"it",
"has",
"an",
"exact",
"underlying",
"field",
"or",
"not",
"and",
"if",
"not",
"an",
"error",
"message",
"why",
"it",
"doesn",
"'",
"t"
] |
[
"public",
"exact",
"get",
"exact",
"info",
"(",
")",
"{",
"return",
"exact",
"exact",
"field",
";",
"}"
] |
[
"retrieve",
"the",
"free",
"marker",
"template",
"specified",
"by",
"the",
"given",
"name",
",",
"using",
"the",
"encoding",
"specified",
"by",
"the",
"\"",
"encoding",
"\"",
"bean",
"property",
"can",
"be",
"called",
"by",
"subclasses",
"to",
"retrieve",
"a",
"specific",
"template",
",",
"for",
"example",
"to",
"render",
"multiple",
"templates",
"into",
"a",
"single",
"view"
] |
[
"protected",
"template",
"get",
"template",
"(",
"string",
"name",
",",
"locale",
"locale",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"(",
"get",
"encoding",
"(",
")",
"!",
"=",
"null",
"?",
"obtain",
"configuration",
"(",
")",
"get",
"template",
"(",
"name",
",",
"locale",
",",
"get",
"encoding",
"(",
")",
")",
":",
"obtain",
"configuration",
"(",
")",
"get",
"template",
"(",
"name",
",",
"locale",
")",
")",
";",
"}"
] |
[
"retrieve",
"the",
"names",
"of",
"all",
"attributes"
] |
[
"public",
"string",
"[",
"]",
"get",
"attribute",
"names",
"(",
")",
"{",
"return",
"string",
"utils",
"to",
"string",
"array",
"(",
"this",
"attributes",
"key",
"set",
"(",
")",
")",
";",
"}"
] |
[
"returns",
"any",
"stored",
"request",
"using",
"{",
"@",
"link",
"android",
"view",
"view",
"#",
"get",
"tag",
"(",
")",
"}",
"for",
"glide",
"to",
"function",
"correctly",
",",
"glide",
"must",
"be",
"the",
"only",
"thing",
"that",
"calls",
"{",
"@",
"link",
"view",
"#",
"set",
"tag",
"(",
"object",
")",
"}",
"if",
"the",
"tag",
"is",
"cleared",
"or",
"put",
"to",
"another",
"object",
"type",
",",
"glide",
"will",
"not",
"be",
"able",
"to",
"retrieve",
"and",
"cancel",
"previous",
"loads",
"which",
"will",
"not",
"only",
"prevent",
"glide",
"from",
"reusing",
"resource",
",",
"but",
"will",
"also",
"result",
"in",
"incorrect",
"images",
"being",
"loaded",
"and",
"lots",
"of",
"flashing",
"of",
"images",
"in",
"lists",
"as",
"a",
"result",
",",
"this",
"will",
"throw",
"an",
"{",
"@",
"link",
"java",
"lang",
"illegal",
"argument",
"exception",
"}",
"if",
"{",
"@",
"link",
"android",
"view",
"view",
"#",
"get",
"tag",
"(",
")",
"}",
"}",
"returns",
"a",
"non",
"null",
"object",
"that",
"is",
"not",
"an",
"{",
"@",
"link",
"com",
"bumptech",
"glide",
"request",
"request",
"}"
] |
[
"public",
"request",
"get",
"request",
"(",
")",
"{",
"object",
"tag",
"=",
"get",
"tag",
"(",
")",
";",
"request",
"request",
"=",
"null",
";",
"if",
"(",
"tag",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"tag",
"instanceof",
"request",
")",
"{",
"request",
"=",
"(",
"request",
")",
"tag",
";",
"}",
"else",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"you",
"must",
"not",
"call",
"set",
"tag",
"(",
")",
"on",
"a",
"view",
"glide",
"is",
"targeting",
"\"",
")",
";",
"}",
"}",
"return",
"request",
";",
"}"
] |
[
"process",
"the",
"queue",
"of",
"commands",
"and",
"dispatch",
"them",
"to",
"the",
"stream",
"this",
"method",
"is",
"only",
"called",
"in",
"the",
"event",
"loop"
] |
[
"private",
"void",
"flush",
"(",
")",
"{",
"perf",
"mark",
"start",
"task",
"(",
"\"",
"write",
"queue",
"periodic",
"flush",
"\"",
")",
";",
"try",
"{",
"queued",
"command",
"cmd",
";",
"int",
"i",
"=",
"0",
";",
"boolean",
"flushed",
"once",
"=",
"false",
";",
"while",
"(",
"(",
"cmd",
"=",
"queue",
"poll",
"(",
")",
")",
"!",
"=",
"null",
")",
"{",
"cmd",
"run",
"(",
"channel",
")",
";",
"if",
"(",
"+",
"+",
"i",
"=",
"=",
"deque",
"chunk",
"size",
")",
"{",
"i",
"=",
"0",
";",
"/",
"/",
"flush",
"each",
"chunk",
"so",
"we",
"are",
"releasing",
"buffers",
"periodically",
"in",
"theory",
"this",
"loop",
"/",
"/",
"might",
"never",
"end",
"as",
"new",
"events",
"are",
"continuously",
"added",
"to",
"the",
"queue",
",",
"if",
"we",
"never",
"/",
"/",
"flushed",
"in",
"that",
"case",
"we",
"would",
"be",
"guaranteed",
"to",
"oom",
"perf",
"mark",
"start",
"task",
"(",
"\"",
"write",
"queue",
"flush",
"0",
"\"",
")",
";",
"try",
"{",
"channel",
"flush",
"(",
")",
";",
"}",
"finally",
"{",
"perf",
"mark",
"stop",
"task",
"(",
"\"",
"write",
"queue",
"flush",
"0",
"\"",
")",
";",
"}",
"flushed",
"once",
"=",
"true",
";",
"}",
"}",
"/",
"/",
"must",
"flush",
"at",
"least",
"once",
",",
"even",
"if",
"there",
"were",
"no",
"writes",
"if",
"(",
"i",
"!",
"=",
"0",
"|",
"|",
"!",
"flushed",
"once",
")",
"{",
"perf",
"mark",
"start",
"task",
"(",
"\"",
"write",
"queue",
"flush",
"1",
"\"",
")",
";",
"try",
"{",
"channel",
"flush",
"(",
")",
";",
"}",
"finally",
"{",
"perf",
"mark",
"stop",
"task",
"(",
"\"",
"write",
"queue",
"flush",
"1",
"\"",
")",
";",
"}",
"}",
"}",
"finally",
"{",
"perf",
"mark",
"stop",
"task",
"(",
"\"",
"write",
"queue",
"periodic",
"flush",
"\"",
")",
";",
"/",
"/",
"mark",
"the",
"write",
"as",
"done",
",",
"if",
"the",
"queue",
"is",
"non",
"-",
"empty",
"after",
"marking",
"trigger",
"a",
"new",
"write",
"scheduled",
"set",
"(",
"false",
")",
";",
"if",
"(",
"!",
"queue",
"is",
"empty",
"(",
")",
")",
"{",
"schedule",
"flush",
"(",
")",
";",
"}",
"}",
"}"
] |
[
"called",
"once",
"an",
"user",
"event",
"hit",
"the",
"end",
"of",
"the",
"{",
"@",
"link",
"channel",
"pipeline",
"}",
"without",
"been",
"handled",
"by",
"the",
"user",
"in",
"{",
"@",
"link",
"channel",
"inbound",
"handler",
"#",
"user",
"event",
"triggered",
"(",
"channel",
"handler",
"context",
",",
"object",
")",
"}",
"this",
"method",
"is",
"responsible",
"to",
"call",
"{",
"@",
"link",
"reference",
"count",
"util",
"#",
"release",
"(",
"object",
")",
"}",
"on",
"the",
"given",
"event",
"at",
"some",
"point"
] |
[
"protected",
"void",
"on",
"unhandled",
"inbound",
"user",
"event",
"triggered",
"(",
"object",
"evt",
")",
"{",
"/",
"/",
"this",
"may",
"not",
"be",
"a",
"configuration",
"error",
"and",
"so",
"don",
"'",
"t",
"log",
"anything",
"/",
"/",
"the",
"event",
"may",
"be",
"superfluous",
"for",
"the",
"current",
"pipeline",
"configuration",
"reference",
"count",
"util",
"release",
"(",
"evt",
")",
";",
"}"
] |
[
"returns",
"the",
"name",
"of",
"the",
"agent",
"it",
"was",
"built",
"on",
";",
"null",
"or",
"\"",
"\"",
"if",
"built",
"by",
"the",
"master",
"(",
"null",
"happens",
"when",
"we",
"read",
"old",
"record",
"that",
"didn",
"'",
"t",
"have",
"this",
"information",
")"
] |
[
"public",
"string",
"get",
"built",
"on",
"str",
"(",
")",
"{",
"return",
"built",
"on",
";",
"}"
] |
[
"absolutizes",
"this",
"{",
"@",
"link",
"file",
"path",
"}",
"and",
"returns",
"the",
"new",
"one"
] |
[
"public",
"file",
"path",
"absolutize",
"(",
")",
"throws",
"i",
"o",
"exception",
",",
"interrupted",
"exception",
"{",
"return",
"new",
"file",
"path",
"(",
"channel",
",",
"act",
"(",
"new",
"absolutize",
"(",
")",
")",
")",
";",
"}"
] |
[
"post",
"user",
":",
"create",
"user",
"this",
"can",
"only",
"be",
"done",
"by",
"the",
"logged",
"in",
"user"
] |
[
"default",
"response",
"entity",
"<",
"void",
">",
"create",
"user",
"(",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"created",
"user",
"object",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"body",
"user",
"body",
")",
"{",
"return",
"new",
"response",
"entity",
"<",
">",
"(",
"http",
"status",
"not",
"implemented",
")",
";",
"}"
] |
[
"verifies",
"that",
"quorum",
"peer",
"exits",
"immediately"
] |
[
"public",
"void",
"test",
"quorum",
"peer",
"exit",
"time",
"(",
")",
"throws",
"exception",
"{",
"long",
"maxwait",
"=",
"3000",
";",
"final",
"int",
"client",
"port",
"qp1",
"=",
"port",
"assignment",
"unique",
"(",
")",
";",
"string",
"quorum",
"cfg",
"section",
"=",
"\"",
"server",
"1",
"=",
"127",
"0",
"0",
"1",
":",
"\"",
"+",
"port",
"assignment",
"unique",
"(",
")",
"+",
"\"",
":",
"\"",
"+",
"port",
"assignment",
"unique",
"(",
")",
"+",
"\"",
";",
"\"",
"+",
"client",
"port",
"qp1",
"+",
"\"",
"\\",
"nserver",
"2",
"=",
"127",
"0",
"0",
"1",
":",
"\"",
"+",
"port",
"assignment",
"unique",
"(",
")",
"+",
"\"",
":",
"\"",
"+",
"port",
"assignment",
"unique",
"(",
")",
"+",
"\"",
";",
"\"",
"+",
"port",
"assignment",
"unique",
"(",
")",
";",
"main",
"thread",
"q",
"1",
"=",
"new",
"main",
"thread",
"(",
"1",
",",
"client",
"port",
"qp1",
",",
"quorum",
"cfg",
"section",
")",
";",
"q",
"1",
"start",
"(",
")",
";",
"/",
"/",
"let",
"the",
"notifications",
"timeout",
"thread",
"sleep",
"(",
"30000",
")",
";",
"long",
"start",
"=",
"time",
"current",
"elapsed",
"time",
"(",
")",
";",
"q",
"1",
"shutdown",
"(",
")",
";",
"long",
"end",
"=",
"time",
"current",
"elapsed",
"time",
"(",
")",
";",
"if",
"(",
"(",
"end",
"-",
"start",
")",
">",
"maxwait",
")",
"{",
"fail",
"(",
"\"",
"quorum",
"peer",
"took",
"\"",
"+",
"(",
"end",
"-",
"start",
")",
"+",
"\"",
"to",
"shutdown",
",",
"expected",
"\"",
"+",
"maxwait",
")",
";",
"}",
"}"
] |
[
"gets",
"the",
"size",
"of",
"this",
"instruction",
",",
"in",
"16",
"-",
"bit",
"code",
"units"
] |
[
"public",
"abstract",
"int",
"code",
"size",
"(",
")",
";"
] |
[
"set",
"leader",
"as",
"new",
"candidate"
] |
[
"public",
"raft",
"peer",
"make",
"leader",
"(",
"raft",
"peer",
"candidate",
")",
"{",
"if",
"(",
"!",
"objects",
"equals",
"(",
"leader",
",",
"candidate",
")",
")",
"{",
"leader",
"=",
"candidate",
";",
"application",
"utils",
"publish",
"event",
"(",
"new",
"make",
"leader",
"event",
"(",
"this",
",",
"leader",
",",
"local",
"(",
")",
")",
")",
";",
"loggers",
"raft",
"info",
"(",
"\"",
"{",
"}",
"has",
"become",
"the",
"leader",
",",
"local",
":",
"{",
"}",
",",
"leader",
":",
"{",
"}",
"\"",
",",
"leader",
"ip",
",",
"jackson",
"utils",
"to",
"json",
"(",
"local",
"(",
")",
")",
",",
"jackson",
"utils",
"to",
"json",
"(",
"leader",
")",
")",
";",
"}",
"for",
"(",
"final",
"raft",
"peer",
"peer",
":",
"peers",
"values",
"(",
")",
")",
"{",
"map",
"<",
"string",
",",
"string",
">",
"params",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
"1",
")",
";",
"if",
"(",
"!",
"objects",
"equals",
"(",
"peer",
",",
"candidate",
")",
"&",
"&",
"peer",
"state",
"=",
"=",
"raft",
"peer",
"state",
"leader",
")",
"{",
"try",
"{",
"string",
"url",
"=",
"raft",
"core",
"build",
"url",
"(",
"peer",
"ip",
",",
"raft",
"core",
"api",
"get",
"peer",
")",
";",
"http",
"client",
"async",
"http",
"get",
"(",
"url",
",",
"null",
",",
"params",
",",
"new",
"callback",
"<",
"string",
">",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"on",
"receive",
"(",
"rest",
"result",
"<",
"string",
">",
"result",
")",
"{",
"if",
"(",
"!",
"result",
"ok",
"(",
")",
")",
"{",
"loggers",
"raft",
"error",
"(",
"\"",
"[",
"nacos",
"-",
"raft",
"]",
"get",
"peer",
"failed",
":",
"{",
"}",
",",
"peer",
":",
"{",
"}",
"\"",
",",
"result",
"get",
"code",
"(",
")",
",",
"peer",
"ip",
")",
";",
"peer",
"state",
"=",
"raft",
"peer",
"state",
"follower",
";",
"return",
";",
"}",
"update",
"(",
"jackson",
"utils",
"to",
"obj",
"(",
"result",
"get",
"data",
"(",
")",
",",
"raft",
"peer",
"class",
")",
")",
";",
"}",
"@",
"override",
"public",
"void",
"on",
"error",
"(",
"throwable",
"throwable",
")",
"{",
"}",
"@",
"override",
"public",
"void",
"on",
"cancel",
"(",
")",
"{",
"}",
"}",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"peer",
"state",
"=",
"raft",
"peer",
"state",
"follower",
";",
"loggers",
"raft",
"error",
"(",
"\"",
"[",
"nacos",
"-",
"raft",
"]",
"error",
"while",
"getting",
"peer",
"from",
"peer",
":",
"{",
"}",
"\"",
",",
"peer",
"ip",
")",
";",
"}",
"}",
"}",
"return",
"update",
"(",
"candidate",
")",
";",
"}"
] |
[
"move",
"a",
"file",
"into",
"a",
"folder",
"displays",
"a",
"error",
"dialog",
"if",
"there",
"was",
"an",
"exception"
] |
[
"private",
"void",
"move",
"file",
"(",
"domain",
"file",
"file",
",",
"domain",
"folder",
"folder",
")",
"{",
"try",
"{",
"string",
"name",
"=",
"file",
"get",
"name",
"(",
")",
";",
"file",
"move",
"to",
"(",
"folder",
")",
";",
"msg",
"info",
"(",
"this",
",",
"\"",
"moved",
"file",
"\"",
"+",
"name",
"+",
"\"",
"to",
"\"",
"+",
"folder",
"to",
"string",
"(",
")",
")",
";",
"}",
"catch",
"(",
"file",
"not",
"found",
"exception",
"e",
")",
"{",
"/",
"/",
"user",
"may",
"have",
"renamed",
"something",
"in",
"this",
"item",
"'",
"s",
"path",
"msg",
"error",
"(",
"this",
",",
"\"",
"file",
"not",
"found",
"'",
"\"",
"+",
"file",
"+",
"\"",
"'",
"\"",
")",
";",
"has",
"failed",
"copy",
"=",
"true",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"client",
"util",
"handle",
"exception",
"(",
"repository",
",",
"e",
",",
"\"",
"move",
"file",
"\"",
",",
"null",
")",
";",
"}",
"}"
] |
[
"change",
"the",
"input",
"policy",
"for",
"this",
"fs"
] |
[
"public",
"void",
"set",
"input",
"policy",
"(",
"s",
"3",
"a",
"input",
"policy",
"input",
"policy",
")",
"{",
"objects",
"require",
"non",
"null",
"(",
"input",
"policy",
",",
"\"",
"null",
"input",
"strategy",
"\"",
")",
";",
"log",
"debug",
"(",
"\"",
"setting",
"input",
"strategy",
":",
"{",
"}",
"\"",
",",
"input",
"policy",
")",
";",
"this",
"input",
"policy",
"=",
"input",
"policy",
";",
"}"
] |
[
"build",
"is",
"blocked",
"because",
"another",
"build",
"is",
"in",
"progress",
",",
"required",
"{",
"@",
"link",
"resource",
"}",
"s",
"are",
"not",
"available",
",",
"or",
"otherwise",
"blocked",
"by",
"{",
"@",
"link",
"task",
"#",
"is",
"build",
"blocked",
"(",
")",
"}"
] |
[
"public",
"boolean",
"is",
"blocked",
"(",
")",
"{",
"return",
"this",
"instanceof",
"blocked",
"item",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"public",
"s",
"q",
"l",
"warning",
"get",
"warnings",
"(",
")",
"throws",
"s",
"q",
"l",
"exception",
"{",
"return",
"null",
";",
"}"
] |
[
"extends",
"the",
"specified",
"{",
"@",
"link",
"bounding",
"box",
"}",
"with",
"the",
"specified",
"part"
] |
[
"public",
"bounding",
"box",
"extend",
"bounding",
"box",
"(",
"final",
"bounding",
"box",
"out",
",",
"int",
"offset",
",",
"int",
"count",
")",
"{",
"return",
"extend",
"bounding",
"box",
"(",
"out",
",",
"offset",
",",
"count",
",",
"null",
")",
";",
"}"
] |
[
"sets",
"server",
"selector",
"threads"
] |
[
"public",
"void",
"set",
"server",
"selector",
"threads",
"(",
"int",
"server",
"selector",
"threads",
")",
"{",
"this",
"server",
"selector",
"threads",
"=",
"server",
"selector",
"threads",
";",
"}"
] |
[
"get",
"petfind",
"by",
"tags",
":",
"finds",
"pets",
"by",
"tags",
"multiple",
"tags",
"can",
"be",
"provided",
"with",
"comma",
"separated",
"strings",
"use",
"tag",
"1",
",",
"tag",
"2",
",",
"tag",
"3",
"for",
"testing"
] |
[
"public",
"response",
"entity",
"<",
"list",
"<",
"pet",
">",
">",
"find",
"pets",
"by",
"tags",
"(",
"@",
"not",
"null",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"tags",
"to",
"filter",
"by",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"param",
"(",
"value",
"=",
"\"",
"tags",
"\"",
",",
"required",
"=",
"true",
")",
"list",
"<",
"string",
">",
"tags",
",",
"@",
"api",
"ignore",
"final",
"pageable",
"pageable",
")",
"{",
"for",
"(",
"media",
"type",
"media",
"type",
":",
"media",
"type",
"parse",
"media",
"types",
"(",
"request",
"get",
"header",
"(",
"\"",
"accept",
"\"",
")",
")",
")",
"{",
"if",
"(",
"media",
"type",
"is",
"compatible",
"with",
"(",
"media",
"type",
"value",
"of",
"(",
"\"",
"application",
"/",
"json",
"\"",
")",
")",
")",
"{",
"string",
"example",
"string",
"=",
"\"",
"{",
"\\",
"\"",
"photo",
"urls",
"\\",
"\"",
":",
"[",
"\\",
"\"",
"photo",
"urls",
"\\",
"\"",
",",
"\\",
"\"",
"photo",
"urls",
"\\",
"\"",
"]",
",",
"\\",
"\"",
"name",
"\\",
"\"",
":",
"\\",
"\"",
"doggie",
"\\",
"\"",
",",
"\\",
"\"",
"id",
"\\",
"\"",
":",
"0",
",",
"\\",
"\"",
"category",
"\\",
"\"",
":",
"{",
"\\",
"\"",
"name",
"\\",
"\"",
":",
"\\",
"\"",
"default",
"-",
"name",
"\\",
"\"",
",",
"\\",
"\"",
"id",
"\\",
"\"",
":",
"6",
"}",
",",
"\\",
"\"",
"tags",
"\\",
"\"",
":",
"[",
"{",
"\\",
"\"",
"name",
"\\",
"\"",
":",
"\\",
"\"",
"name",
"\\",
"\"",
",",
"\\",
"\"",
"id",
"\\",
"\"",
":",
"1",
"}",
",",
"{",
"\\",
"\"",
"name",
"\\",
"\"",
":",
"\\",
"\"",
"name",
"\\",
"\"",
",",
"\\",
"\"",
"id",
"\\",
"\"",
":",
"1",
"}",
"]",
",",
"\\",
"\"",
"status",
"\\",
"\"",
":",
"\\",
"\"",
"available",
"\\",
"\"",
"}",
"\"",
";",
"api",
"util",
"set",
"example",
"response",
"(",
"request",
",",
"\"",
"application",
"/",
"json",
"\"",
",",
"example",
"string",
")",
";",
"break",
";",
"}",
"if",
"(",
"media",
"type",
"is",
"compatible",
"with",
"(",
"media",
"type",
"value",
"of",
"(",
"\"",
"application",
"/",
"xml",
"\"",
")",
")",
")",
"{",
"string",
"example",
"string",
"=",
"\"",
"<",
"pet",
">",
"<",
"id",
">",
"123456789",
"<",
"/",
"id",
">",
"<",
"name",
">",
"doggie",
"<",
"/",
"name",
">",
"<",
"photo",
"urls",
">",
"<",
"photo",
"urls",
">",
"aeiou",
"<",
"/",
"photo",
"urls",
">",
"<",
"/",
"photo",
"urls",
">",
"<",
"tags",
">",
"<",
"/",
"tags",
">",
"<",
"status",
">",
"aeiou",
"<",
"/",
"status",
">",
"<",
"/",
"pet",
">",
"\"",
";",
"api",
"util",
"set",
"example",
"response",
"(",
"request",
",",
"\"",
"application",
"/",
"xml",
"\"",
",",
"example",
"string",
")",
";",
"break",
";",
"}",
"}",
"return",
"new",
"response",
"entity",
"<",
">",
"(",
"http",
"status",
"not",
"implemented",
")",
";",
"}"
] |
[
"set",
"payload",
"size",
"of",
"the",
"stream",
"it",
"is",
"intended",
"to",
"be",
"used",
"for",
"unit",
"testing",
"purposes",
"only"
] |
[
"synchronized",
"void",
"set",
"max",
"block",
"size",
"(",
"int",
"size",
")",
"{",
"max",
"block",
"size",
"set",
"(",
"size",
")",
";",
"/",
"/",
"it",
"is",
"for",
"testing",
"only",
"so",
"we",
"can",
"abandon",
"the",
"previously",
"allocated",
"/",
"/",
"payload",
"this",
"out",
"buffer",
"=",
"byte",
"buffer",
"allocate",
"(",
"max",
"block",
"size",
"get",
"(",
")",
")",
";",
"}"
] |
[
"builds",
"configured",
"{",
"@",
"link",
"image",
"loader",
"configuration",
"}",
"object"
] |
[
"public",
"image",
"loader",
"configuration",
"build",
"(",
")",
"{",
"init",
"empty",
"fields",
"with",
"default",
"values",
"(",
")",
";",
"return",
"new",
"image",
"loader",
"configuration",
"(",
"this",
")",
";",
"}"
] |
[
"visit",
"a",
"parse",
"tree",
"produced",
"by",
"{",
"@",
"link",
"eql",
"base",
"parser",
"#",
"expression",
"}"
] |
[
"t",
"visit",
"expression",
"(",
"eql",
"base",
"parser",
"expression",
"context",
"ctx",
")",
";"
] |
[
"get",
"pet",
"id"
] |
[
"public",
"long",
"get",
"pet",
"id",
"(",
")",
"{",
"return",
"pet",
"id",
";",
"}"
] |
[
"tests",
"if",
"the",
"presenter",
"was",
"successfully",
"connected",
"with",
"the",
"view"
] |
[
"public",
"void",
"wiring",
"(",
")",
"{",
"presenter",
"start",
"(",
")",
";",
"assert",
"not",
"null",
"(",
"stub",
"get",
"presenter",
"(",
")",
")",
";",
"assert",
"true",
"(",
"stub",
"is",
"opened",
"(",
")",
")",
";",
"}"
] |
[
"inserts",
"the",
"specified",
"element",
"at",
"the",
"end",
"of",
"this",
"deque",
"unless",
"it",
"would",
"violate",
"capacity",
"restrictions",
"when",
"using",
"a",
"capacity",
"-",
"restricted",
"deque",
",",
"this",
"method",
"is",
"generally",
"preferable",
"to",
"the",
"{",
"@",
"link",
"#",
"add",
"last",
"}",
"method",
",",
"which",
"can",
"fail",
"to",
"insert",
"an",
"element",
"only",
"by",
"throwing",
"an",
"exception"
] |
[
"boolean",
"offer",
"last",
"(",
"e",
"e",
")",
";"
] |
[
"specifies",
"which",
"open",
"j",
"d",
"k",
"version",
"to",
"use",
"if",
"not",
"provided",
"explicitly",
",",
"the",
"image",
"version",
"will",
"be",
"derived",
"based",
"on",
"the",
"version",
"of",
"the",
"java",
"that",
"runs",
"the",
"test"
] |
[
"public",
"flink",
"container",
"builder",
"java",
"version",
"(",
"string",
"java",
"version",
")",
"{",
"this",
"java",
"version",
"=",
"java",
"version",
";",
"return",
"this",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.