docstring_tokens
list | code_tokens
list |
|---|---|
[
"sets",
"the",
"{",
"@",
"code",
"settings",
"max",
"header",
"list",
"size",
"}",
"value"
] |
[
"public",
"http",
"2",
"settings",
"max",
"header",
"list",
"size",
"(",
"long",
"value",
")",
"{",
"put",
"(",
"settings",
"max",
"header",
"list",
"size",
",",
"long",
"value",
"of",
"(",
"value",
")",
")",
";",
"return",
"this",
";",
"}"
] |
[
"called",
"when",
"cluster",
"state",
"changes"
] |
[
"void",
"cluster",
"changed",
"(",
"cluster",
"changed",
"event",
"event",
")",
";"
] |
[
"generates",
"a",
"pseudo",
"-",
"random",
"number"
] |
[
"static",
"int",
"random",
"number",
"(",
"int",
"minimum",
",",
"int",
"maximum",
")",
"{",
"assert",
"minimum",
"<",
"maximum",
";",
"double",
"fraction",
"=",
"platform",
"dependent",
"thread",
"local",
"random",
"(",
")",
"next",
"double",
"(",
")",
";",
"/",
"/",
"the",
"idea",
"here",
"is",
"that",
"next",
"double",
"gives",
"us",
"a",
"random",
"value",
"/",
"/",
"/",
"/",
"0",
"<",
"=",
"fraction",
"<",
"=",
"1",
"/",
"/",
"/",
"/",
"the",
"distance",
"from",
"min",
"to",
"max",
"declared",
"as",
"/",
"/",
"/",
"/",
"dist",
"=",
"max",
"-",
"min",
"/",
"/",
"/",
"/",
"satisfies",
"the",
"following",
"/",
"/",
"/",
"/",
"min",
"+",
"dist",
"=",
"max",
"/",
"/",
"/",
"/",
"taking",
"into",
"account",
"/",
"/",
"/",
"/",
"0",
"<",
"=",
"fraction",
"*",
"dist",
"<",
"=",
"dist",
"/",
"/",
"/",
"/",
"we",
"'",
"ve",
"got",
"/",
"/",
"/",
"/",
"min",
"<",
"=",
"min",
"+",
"fraction",
"*",
"dist",
"<",
"=",
"max",
"return",
"(",
"int",
")",
"(",
"minimum",
"+",
"fraction",
"*",
"(",
"maximum",
"-",
"minimum",
")",
")",
";",
"}"
] |
[
"returns",
"true",
"if",
"this",
"is",
"an",
"executable",
"file",
"<",
"br",
">",
"e",
"type",
"=",
"=",
"new",
"elf",
"header",
"constants",
"et",
"exec"
] |
[
"public",
"boolean",
"is",
"executable",
"(",
")",
"{",
"return",
"e",
"type",
"=",
"=",
"elf",
"constants",
"et",
"exec",
";",
"}"
] |
[
"finds",
"a",
"descriptor",
"from",
"a",
"collection",
"by",
"the",
"class",
"name",
"of",
"the",
"{",
"@",
"link",
"describable",
"}",
"it",
"describes"
] |
[
"public",
"static",
"@",
"check",
"for",
"null",
"<",
"t",
"extends",
"descriptor",
">",
"t",
"find",
"by",
"describable",
"class",
"name",
"(",
"collection",
"<",
"?",
"extends",
"t",
">",
"list",
",",
"string",
"class",
"name",
")",
"{",
"for",
"(",
"t",
"d",
":",
"list",
")",
"{",
"if",
"(",
"d",
"clazz",
"get",
"name",
"(",
")",
"equals",
"(",
"class",
"name",
")",
")",
"return",
"d",
";",
"}",
"return",
"null",
";",
"}"
] |
[
"this",
"implementation",
"returns",
"a",
"shallow",
"copy",
"of",
"this",
"invocation",
"object",
",",
"using",
"the",
"given",
"arguments",
"array",
"for",
"the",
"clone",
"we",
"want",
"a",
"shallow",
"copy",
"in",
"this",
"case",
":",
"we",
"want",
"to",
"use",
"the",
"same",
"interceptor",
"chain",
"and",
"other",
"object",
"references",
",",
"but",
"we",
"want",
"an",
"independent",
"value",
"for",
"the",
"current",
"interceptor",
"index"
] |
[
"public",
"method",
"invocation",
"invocable",
"clone",
"(",
"object",
"arguments",
")",
"{",
"/",
"/",
"force",
"initialization",
"of",
"the",
"user",
"attributes",
"map",
",",
"/",
"/",
"for",
"having",
"a",
"shared",
"map",
"reference",
"in",
"the",
"clone",
"if",
"(",
"this",
"user",
"attributes",
"=",
"=",
"null",
")",
"{",
"this",
"user",
"attributes",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"}",
"/",
"/",
"create",
"the",
"method",
"invocation",
"clone",
"try",
"{",
"reflective",
"method",
"invocation",
"clone",
"=",
"(",
"reflective",
"method",
"invocation",
")",
"clone",
"(",
")",
";",
"clone",
"arguments",
"=",
"arguments",
";",
"return",
"clone",
";",
"}",
"catch",
"(",
"clone",
"not",
"supported",
"exception",
"ex",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"should",
"be",
"able",
"to",
"clone",
"object",
"of",
"type",
"[",
"\"",
"+",
"get",
"class",
"(",
")",
"+",
"\"",
"]",
":",
"\"",
"+",
"ex",
")",
";",
"}",
"}"
] |
[
"test",
"the",
"property",
"'",
"att",
"name",
"'"
] |
[
"public",
"void",
"att",
"n",
"a",
"m",
"e",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"att",
"name",
"}"
] |
[
"returns",
"a",
"set",
"of",
"the",
"names",
"of",
"all",
"registered",
"health",
"checks"
] |
[
"public",
"sorted",
"set",
"<",
"string",
">",
"get",
"names",
"(",
")",
"{",
"return",
"collections",
"unmodifiable",
"sorted",
"set",
"(",
"new",
"tree",
"set",
"<",
">",
"(",
"health",
"checks",
"key",
"set",
"(",
")",
")",
")",
";",
"}"
] |
[
"start",
"a",
"new",
"(",
"indented",
")",
"line",
"of",
"output"
] |
[
"protected",
"void",
"startln",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"for",
"(",
"@",
"suppress",
"warnings",
"(",
"\"",
"unused",
"\"",
")",
"long",
"l",
":",
"time",
"stack",
")",
"{",
"out",
"write",
"(",
"'",
"'",
")",
";",
"out",
"write",
"(",
"'",
"'",
")",
";",
"}",
"}"
] |
[
"decoding",
"for",
"dictionary",
"ids",
"the",
"i",
"ds",
"are",
"populated",
"into",
"`",
"values",
"`",
"and",
"the",
"nullability",
"is",
"populated",
"into",
"`",
"nulls",
"`"
] |
[
"void",
"read",
"dictionary",
"ids",
"(",
"int",
"total",
",",
"writable",
"int",
"vector",
"values",
",",
"writable",
"column",
"vector",
"nulls",
",",
"int",
"row",
"id",
",",
"int",
"level",
",",
"run",
"length",
"decoder",
"data",
")",
"{",
"int",
"left",
"=",
"total",
";",
"while",
"(",
"left",
">",
"0",
")",
"{",
"if",
"(",
"this",
"current",
"count",
"=",
"=",
"0",
")",
"{",
"this",
"read",
"next",
"group",
"(",
")",
";",
"}",
"int",
"n",
"=",
"math",
"min",
"(",
"left",
",",
"this",
"current",
"count",
")",
";",
"switch",
"(",
"mode",
")",
"{",
"case",
"rle",
":",
"if",
"(",
"current",
"value",
"=",
"=",
"level",
")",
"{",
"data",
"read",
"dictionary",
"id",
"data",
"(",
"n",
",",
"values",
",",
"row",
"id",
")",
";",
"}",
"else",
"{",
"nulls",
"set",
"nulls",
"(",
"row",
"id",
",",
"n",
")",
";",
"}",
"break",
";",
"case",
"packed",
":",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"n",
";",
"+",
"+",
"i",
")",
"{",
"if",
"(",
"current",
"buffer",
"[",
"current",
"buffer",
"idx",
"+",
"+",
"]",
"=",
"=",
"level",
")",
"{",
"values",
"set",
"int",
"(",
"row",
"id",
"+",
"i",
",",
"data",
"read",
"integer",
"(",
")",
")",
";",
"}",
"else",
"{",
"nulls",
"set",
"null",
"at",
"(",
"row",
"id",
"+",
"i",
")",
";",
"}",
"}",
"break",
";",
"}",
"row",
"id",
"+",
"=",
"n",
";",
"left",
"-",
"=",
"n",
";",
"current",
"count",
"-",
"=",
"n",
";",
"}",
"}"
] |
[
"creates",
"default",
"options",
"for",
"this",
"particular",
"demangler"
] |
[
"public",
"default",
"demangler",
"options",
"create",
"default",
"options",
"(",
")",
"{",
"return",
"new",
"demangler",
"options",
"(",
")",
";",
"}"
] |
[
"optional",
":",
"default",
"value",
"is",
"<",
"b",
">",
"{",
"@",
"value",
"prop",
"defaults",
"view",
"#",
"string",
"default",
"}",
"<",
"b",
">"
] |
[
"public",
"prop",
"defaults",
"view",
"model",
"object",
"with",
"default",
"and",
"nullable",
"(",
"@",
"nullable",
"string",
"object",
"with",
"default",
"and",
"nullable",
")",
"{",
"on",
"mutation",
"(",
")",
";",
"this",
"object",
"with",
"default",
"and",
"nullable",
"string",
"=",
"object",
"with",
"default",
"and",
"nullable",
";",
"return",
"this",
";",
"}"
] |
[
"this",
"goes",
"through",
"the",
"keyset",
"of",
"one",
"configuration",
"and",
"retrieves",
"each",
"value",
"from",
"a",
"value",
"source",
"-",
"a",
"different",
"or",
"the",
"same",
"configuration",
"this",
"triggers",
"the",
"property",
"resolution",
"process",
"of",
"the",
"value",
",",
"resolving",
"any",
"variables",
"against",
"in",
"-",
"config",
"or",
"inherited",
"configurations"
] |
[
"public",
"static",
"configuration",
"resolve",
"configuration",
"(",
"iterable",
"<",
"map",
"entry",
"<",
"string",
",",
"string",
">",
">",
"keysource",
",",
"configuration",
"valuesource",
")",
"{",
"configuration",
"result",
"=",
"new",
"configuration",
"(",
"false",
")",
";",
"for",
"(",
"map",
"entry",
"<",
"string",
",",
"string",
">",
"entry",
":",
"keysource",
")",
"{",
"string",
"key",
"=",
"entry",
"get",
"key",
"(",
")",
";",
"string",
"value",
"=",
"valuesource",
"get",
"(",
"key",
")",
";",
"preconditions",
"check",
"state",
"(",
"value",
"!",
"=",
"null",
",",
"\"",
"no",
"reference",
"for",
"\\",
"\"",
"%",
"s",
"\\",
"\"",
"in",
"values",
"\"",
",",
"key",
")",
";",
"result",
"set",
"(",
"key",
",",
"value",
")",
";",
"}",
"return",
"result",
";",
"}"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"template",
"method",
"that",
"reads",
"the",
"json",
"-",
"bound",
"object",
"from",
"the",
"given",
"{",
"@",
"link",
"reader",
"}"
] |
[
"protected",
"abstract",
"object",
"read",
"internal",
"(",
"type",
"resolved",
"type",
",",
"reader",
"reader",
")",
"throws",
"exception",
";"
] |
[
"creates",
"a",
"new",
"uninitialized",
"this",
"type"
] |
[
"public",
"static",
"uninitialized",
"this",
"type",
"create",
"uninitialized",
"this",
"type",
"(",
")",
"{",
"return",
"uninitialized",
"this",
"type",
";",
"}"
] |
[
"a",
"{",
"@",
"link",
"channel",
"}",
"received",
"an",
"{",
"@",
"link",
"throwable",
"}",
"in",
"one",
"of",
"its",
"inbound",
"operations",
"this",
"will",
"result",
"in",
"having",
"the",
"{",
"@",
"link",
"channel",
"inbound",
"handler",
"#",
"exception",
"caught",
"(",
"channel",
"handler",
"context",
",",
"throwable",
")",
"}",
"method",
"called",
"of",
"the",
"next",
"{",
"@",
"link",
"channel",
"inbound",
"handler",
"}",
"contained",
"in",
"the",
"{",
"@",
"link",
"channel",
"pipeline",
"}",
"of",
"the",
"{",
"@",
"link",
"channel",
"}"
] |
[
"channel",
"inbound",
"invoker",
"fire",
"exception",
"caught",
"(",
"throwable",
"cause",
")",
";"
] |
[
"sanitize",
"filename",
"by",
"removing",
"path",
"e",
"g",
"sun",
"gif",
"becomes",
"sun",
"gif"
] |
[
"protected",
"string",
"sanitize",
"filename",
"(",
"string",
"filename",
")",
"{",
"return",
"filename",
"replace",
"all",
"(",
"\"",
"*",
"[",
"/",
"\\",
"\\",
"\\",
"\\",
"]",
"\"",
",",
"\"",
"\"",
")",
";",
"}"
] |
[
"convert",
"input",
"markdown",
"text",
"to",
"html",
"simple",
"text",
"is",
"not",
"wrapped",
"in"
] |
[
"public",
"string",
"to",
"html",
"(",
"string",
"markdown",
")",
"{",
"if",
"(",
"markdown",
"=",
"=",
"null",
")",
"return",
"\"",
"\"",
";",
"node",
"document",
"=",
"parser",
"parse",
"(",
"markdown",
")",
";",
"string",
"html",
"=",
"renderer",
"render",
"(",
"document",
")",
";",
"html",
"=",
"unwrapped",
"(",
"html",
")",
";",
"return",
"html",
";",
"}"
] |
[
"resolve",
"the",
"ip",
"from",
"the",
"string",
"containing",
"the",
"ip",
"address"
] |
[
"public",
"static",
"string",
"get",
"i",
"p",
"from",
"string",
"(",
"string",
"str",
")",
"{",
"if",
"(",
"string",
"utils",
"is",
"blank",
"(",
"str",
")",
")",
"{",
"return",
"\"",
"\"",
";",
"}",
"string",
"result",
"=",
"\"",
"\"",
";",
"if",
"(",
"string",
"utils",
"contains",
"ignore",
"case",
"(",
"str",
",",
"ipv6",
"start",
"mark",
")",
"&",
"&",
"string",
"utils",
"contains",
"ignore",
"case",
"(",
"str",
",",
"ipv6",
"end",
"mark",
")",
")",
"{",
"result",
"=",
"str",
"substring",
"(",
"str",
"index",
"of",
"(",
"ipv6",
"start",
"mark",
")",
",",
"(",
"str",
"index",
"of",
"(",
"ipv6",
"end",
"mark",
")",
"+",
"1",
")",
")",
";",
"if",
"(",
"!",
"is",
"i",
"pv",
"6",
"(",
"result",
")",
")",
"{",
"result",
"=",
"\"",
"\"",
";",
"}",
"}",
"else",
"{",
"matcher",
"m",
"=",
"ipv",
"4",
"pattern",
"matcher",
"(",
"str",
")",
";",
"if",
"(",
"m",
"find",
"(",
")",
")",
"{",
"result",
"=",
"m",
"group",
"(",
")",
";",
"if",
"(",
"!",
"is",
"i",
"pv",
"4",
"(",
"result",
")",
")",
"{",
"result",
"=",
"\"",
"\"",
";",
"}",
"}",
"}",
"return",
"result",
";",
"}"
] |
[
"return",
"the",
"char",
"mapped",
"to",
"the",
"given",
"entity",
"reference",
"or",
"-",
"1"
] |
[
"public",
"char",
"convert",
"to",
"character",
"(",
"string",
"entity",
"reference",
")",
"{",
"character",
"referred",
"character",
"=",
"this",
"entity",
"reference",
"to",
"character",
"map",
"get",
"(",
"entity",
"reference",
")",
";",
"if",
"(",
"referred",
"character",
"!",
"=",
"null",
")",
"{",
"return",
"referred",
"character",
";",
"}",
"return",
"char",
"null",
";",
"}"
] |
[
"remove",
"a",
"mount",
"table",
"entry",
"to",
"the",
"mount",
"table",
"through",
"the",
"admin",
"api"
] |
[
"private",
"boolean",
"remove",
"mount",
"table",
"(",
"string",
"path",
")",
"throws",
"i",
"o",
"exception",
"{",
"router",
"client",
"client",
"=",
"router",
"context",
"get",
"admin",
"client",
"(",
")",
";",
"mount",
"table",
"manager",
"mount",
"table",
"manager",
"=",
"client",
"get",
"mount",
"table",
"manager",
"(",
")",
";",
"remove",
"mount",
"table",
"entry",
"request",
"remove",
"request",
"=",
"remove",
"mount",
"table",
"entry",
"request",
"new",
"instance",
"(",
"path",
")",
";",
"remove",
"mount",
"table",
"entry",
"response",
"remove",
"response",
"=",
"mount",
"table",
"manager",
"remove",
"mount",
"table",
"entry",
"(",
"remove",
"request",
")",
";",
"/",
"/",
"reload",
"the",
"router",
"cache",
"resolver",
"load",
"cache",
"(",
"true",
")",
";",
"return",
"remove",
"response",
"get",
"status",
"(",
")",
";",
"}"
] |
[
"show",
"the",
"soft",
"input"
] |
[
"public",
"static",
"void",
"show",
"soft",
"input",
"(",
"@",
"non",
"null",
"final",
"view",
"view",
")",
"{",
"show",
"soft",
"input",
"(",
"view",
",",
"0",
")",
";",
"}"
] |
[
"adds",
"the",
"given",
"owner",
"name",
"to",
"this",
"stub",
"this",
"is",
"used",
"to",
"display",
"all",
"known",
"clients",
"of",
"the",
"action",
"represented",
"by",
"this",
"stub",
"normally",
",",
"when",
"this",
"class",
"has",
"actions",
",",
"the",
"names",
"of",
"each",
"action",
"'",
"s",
"owner",
"would",
"be",
"used",
"directly",
"however",
",",
"this",
"class",
"can",
"also",
"be",
"used",
"as",
"a",
"placeholder",
",",
"when",
"no",
"actions",
"have",
"yet",
"been",
"registered",
"in",
"that",
"case",
",",
"the",
"owner",
"has",
"to",
"be",
"set",
"directly",
"on",
"this",
"stub"
] |
[
"void",
"add",
"action",
"owner",
"(",
"string",
"owner",
")",
"{",
"if",
"(",
"docking",
"window",
"manager",
"docking",
"windows",
"owner",
"equals",
"(",
"owner",
")",
")",
"{",
"/",
"/",
"special",
"case",
":",
"special",
"system",
"-",
"level",
"action",
"owner",
";",
"the",
"user",
"does",
"not",
"need",
"to",
"see",
"return",
";",
"}",
"action",
"owners",
"add",
"(",
"owner",
")",
";",
"}"
] |
[
"logs",
"user",
"into",
"the",
"system"
] |
[
"public",
"void",
"login",
"user",
"test",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"string",
"username",
"=",
"null",
";",
"string",
"password",
"=",
"null",
";",
"string",
"response",
"=",
"api",
"login",
"user",
"(",
"username",
",",
"password",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
] |
[
"test",
"code",
"generation",
"for",
"any",
"type",
"here",
"the",
"&",
"#",
"39",
";",
"type",
"&",
"#",
"39",
";",
"attribute",
"is",
"not",
"specified",
",",
"which",
"means",
"the",
"value",
"can",
"be",
"anything",
",",
"including",
"the",
"null",
"value",
",",
"string",
",",
"number",
",",
"boolean",
",",
"array",
"or",
"object",
"the",
"&",
"#",
"39",
";",
"nullable",
"&",
"#",
"39",
";",
"attribute",
"does",
"not",
"change",
"the",
"allowed",
"values"
] |
[
"public",
"object",
"get",
"any",
"type",
"prop",
"nullable",
"(",
")",
"{",
"return",
"any",
"type",
"prop",
"nullable",
"or",
"else",
"(",
"null",
")",
";",
"}"
] |
[
"if",
"cgroups",
"in",
"enabled",
"and",
"not",
"set",
"to",
"none",
",",
"then",
"set",
"the",
"cgroup",
"parent",
"for",
"the",
"command",
"instance"
] |
[
"protected",
"void",
"add",
"c",
"group",
"parent",
"if",
"required",
"(",
"string",
"resources",
"options",
",",
"string",
"container",
"id",
"str",
",",
"docker",
"run",
"command",
"run",
"command",
")",
"{",
"if",
"(",
"c",
"groups",
"handler",
"=",
"=",
"null",
")",
"{",
"log",
"debug",
"(",
"\"",
"c",
"groups",
"handler",
"is",
"null",
"cgroups",
"are",
"not",
"in",
"use",
"nothing",
"to",
"\"",
"+",
"\"",
"do",
"\"",
")",
";",
"return",
";",
"}",
"if",
"(",
"resources",
"options",
"equals",
"(",
"privileged",
"operation",
"cgroup",
"arg",
"prefix",
"+",
"privileged",
"operation",
"cgroup",
"arg",
"no",
"tasks",
")",
")",
"{",
"log",
"debug",
"(",
"\"",
"no",
"resource",
"restrictions",
"specified",
"not",
"using",
"docker",
"'",
"s",
"\"",
"+",
"\"",
"cgroup",
"options",
"\"",
")",
";",
"}",
"else",
"{",
"log",
"debug",
"(",
"\"",
"using",
"docker",
"'",
"s",
"cgroups",
"options",
"\"",
")",
";",
"string",
"c",
"group",
"path",
"=",
"\"",
"/",
"\"",
"+",
"c",
"groups",
"handler",
"get",
"relative",
"path",
"for",
"c",
"group",
"(",
"container",
"id",
"str",
")",
";",
"log",
"debug",
"(",
"\"",
"using",
"cgroup",
"parent",
":",
"{",
"}",
"\"",
",",
"c",
"group",
"path",
")",
";",
"run",
"command",
"set",
"c",
"group",
"parent",
"(",
"c",
"group",
"path",
")",
";",
"}",
"}"
] |
[
"lower",
"bound",
"binary",
"search",
"find",
"the",
"index",
"to",
"the",
"first",
"element",
"in",
"the",
"list",
"that",
"compares",
"greater",
"than",
"or",
"equal",
"to",
"key"
] |
[
"public",
"static",
"<",
"t",
">",
"int",
"lower",
"bound",
"(",
"list",
"<",
"?",
"extends",
"t",
">",
"list",
",",
"t",
"key",
",",
"comparator",
"<",
"?",
"super",
"t",
">",
"cmp",
")",
"{",
"int",
"low",
"=",
"0",
";",
"int",
"high",
"=",
"list",
"size",
"(",
")",
";",
"while",
"(",
"low",
"<",
"high",
")",
"{",
"int",
"mid",
"=",
"(",
"low",
"+",
"high",
")",
">",
">",
">",
"1",
";",
"t",
"mid",
"val",
"=",
"list",
"get",
"(",
"mid",
")",
";",
"int",
"ret",
"=",
"cmp",
"compare",
"(",
"mid",
"val",
",",
"key",
")",
";",
"if",
"(",
"ret",
"<",
"0",
")",
"low",
"=",
"mid",
"+",
"1",
";",
"else",
"high",
"=",
"mid",
";",
"}",
"return",
"low",
";",
"}"
] |
[
"return",
"the",
"configured",
"naming",
"strategy",
"or",
"{",
"@",
"code",
"null",
"}"
] |
[
"public",
"handler",
"method",
"mapping",
"naming",
"strategy",
"<",
"t",
">",
"get",
"naming",
"strategy",
"(",
")",
"{",
"return",
"this",
"naming",
"strategy",
";",
"}"
] |
[
"set",
"the",
"maximum",
"allowed",
"size",
"(",
"in",
"bytes",
")",
"for",
"each",
"individual",
"file",
"before",
"an",
"upload",
"gets",
"rejected",
"-",
"1",
"indicates",
"no",
"limit",
"(",
"the",
"default",
")"
] |
[
"public",
"void",
"set",
"max",
"upload",
"size",
"per",
"file",
"(",
"long",
"max",
"upload",
"size",
"per",
"file",
")",
"{",
"this",
"file",
"upload",
"set",
"file",
"size",
"max",
"(",
"max",
"upload",
"size",
"per",
"file",
")",
";",
"}"
] |
[
"don",
"'",
"t",
"bother",
"to",
"memoize",
"hash",
"code",
"because",
"{",
"@",
"link",
"recursive",
"pkg",
"key",
"#",
"hash",
"code",
"}",
"is",
"cheap",
"enough"
] |
[
"public",
"int",
"hash",
"code",
"(",
")",
"{",
"return",
"37",
"*",
"super",
"hash",
"code",
"(",
")",
"+",
"function",
"name",
"(",
")",
"hash",
"code",
"(",
")",
";",
"}"
] |
[
"public",
"method",
"which",
"will",
"receive",
"request",
"from",
"{",
"@",
"link",
"com",
"iluwatar",
"commander",
"commander",
"}"
] |
[
"public",
"string",
"receive",
"request",
"(",
"object",
"parameters",
")",
"throws",
"database",
"unavailable",
"exception",
"{",
"var",
"id",
"=",
"generate",
"id",
"(",
")",
";",
"var",
"item",
"=",
"(",
"string",
")",
"parameters",
"[",
"0",
"]",
";",
"var",
"address",
"=",
"(",
"string",
")",
"parameters",
"[",
"1",
"]",
";",
"var",
"req",
"=",
"new",
"shipping",
"request",
"(",
"id",
",",
"item",
",",
"address",
")",
";",
"return",
"update",
"db",
"(",
"req",
")",
";",
"}"
] |
[
"return",
"the",
"url",
"of",
"the",
"request"
] |
[
"public",
"string",
"get",
"request",
"url",
"(",
")",
"{",
"return",
"this",
"request",
"url",
";",
"}"
] |
[
"computes",
"a",
"digest",
"of",
"the",
"given",
"proto",
"message",
"currently",
",",
"we",
"simply",
"rely",
"on",
"message",
"output",
"as",
"bytes",
",",
"but",
"this",
"implementation",
"relies",
"on",
"the",
"stability",
"of",
"the",
"proto",
"encoding",
",",
"in",
"particular",
"between",
"different",
"platforms",
"and",
"languages",
"todo",
"(",
"olaola",
")",
":",
"upgrade",
"to",
"a",
"better",
"implementation",
"!"
] |
[
"public",
"digest",
"compute",
"(",
"message",
"message",
")",
"{",
"return",
"compute",
"(",
"message",
"to",
"byte",
"array",
"(",
")",
")",
";",
"}"
] |
[
"returns",
"the",
"type",
"index",
"for",
"the",
"arguments",
"list"
] |
[
"public",
"abstract",
"ms",
"type",
"get",
"arguments",
"list",
"type",
"(",
")",
"{",
"return",
"pdb",
"get",
"type",
"record",
"(",
"arg",
"list",
"record",
"number",
")",
";",
"}"
] |
[
"requests",
"that",
"the",
"name",
"node",
"download",
"an",
"image",
"from",
"this",
"node",
"allows",
"for",
"optional",
"external",
"cancelation"
] |
[
"public",
"static",
"transfer",
"result",
"upload",
"image",
"from",
"storage",
"(",
"url",
"fs",
"name",
",",
"configuration",
"conf",
",",
"n",
"n",
"storage",
"storage",
",",
"name",
"node",
"file",
"nnf",
",",
"long",
"txid",
",",
"canceler",
"canceler",
")",
"throws",
"i",
"o",
"exception",
"{",
"url",
"url",
"=",
"new",
"url",
"(",
"fs",
"name",
",",
"image",
"servlet",
"path",
"spec",
")",
";",
"long",
"start",
"time",
"=",
"time",
"monotonic",
"now",
"(",
")",
";",
"try",
"{",
"upload",
"image",
"(",
"url",
",",
"conf",
",",
"storage",
",",
"nnf",
",",
"txid",
",",
"canceler",
")",
";",
"}",
"catch",
"(",
"http",
"put",
"failed",
"exception",
"e",
")",
"{",
"/",
"/",
"translate",
"the",
"error",
"code",
"to",
"a",
"result",
",",
"which",
"is",
"a",
"bit",
"more",
"obvious",
"in",
"usage",
"transfer",
"result",
"result",
"=",
"transfer",
"result",
"get",
"result",
"for",
"code",
"(",
"e",
"get",
"response",
"code",
"(",
")",
")",
";",
"if",
"(",
"result",
"should",
"re",
"throw",
"exception",
")",
"{",
"throw",
"e",
";",
"}",
"return",
"result",
";",
"}",
"double",
"xfer",
"sec",
"=",
"math",
"max",
"(",
"(",
"(",
"float",
")",
"(",
"time",
"monotonic",
"now",
"(",
")",
"-",
"start",
"time",
")",
")",
"/",
"1000",
"0",
",",
"0",
"001",
")",
";",
"log",
"info",
"(",
"\"",
"uploaded",
"image",
"with",
"txid",
"\"",
"+",
"txid",
"+",
"\"",
"to",
"namenode",
"at",
"\"",
"+",
"fs",
"name",
"+",
"\"",
"in",
"\"",
"+",
"xfer",
"sec",
"+",
"\"",
"seconds",
"\"",
")",
";",
"return",
"transfer",
"result",
"success",
";",
"}"
] |
[
"decorate",
"the",
"given",
"bean",
"definition",
"through",
"a",
"namespace",
"handler",
",",
"if",
"applicable"
] |
[
"public",
"bean",
"definition",
"holder",
"decorate",
"bean",
"definition",
"if",
"required",
"(",
"element",
"ele",
",",
"bean",
"definition",
"holder",
"original",
"def",
")",
"{",
"return",
"decorate",
"bean",
"definition",
"if",
"required",
"(",
"ele",
",",
"original",
"def",
",",
"null",
")",
";",
"}"
] |
[
"whether",
"the",
"symbol",
"can",
"be",
"merged",
"into",
"another",
"resource",
"table",
"without",
"there",
"being",
"an",
"existing",
"definition",
"to",
"override",
"used",
"for",
"overlays",
"and",
"set",
"to",
"true",
"when",
"&",
"lt",
";",
"add",
"-",
"resource",
"&",
"gt",
";",
"is",
"specified",
"<",
"code",
">",
"optional",
"bool",
"allow",
"new",
"=",
"4",
";",
"<",
"code",
">"
] |
[
"public",
"boolean",
"get",
"allow",
"new",
"(",
")",
"{",
"return",
"instance",
"get",
"allow",
"new",
"(",
")",
";",
"}"
] |
[
"n",
"b",
":",
"may",
"silently",
"throw",
"{",
"@",
"link",
"com",
"google",
"devtools",
"build",
"lib",
"packages",
"no",
"such",
"package",
"exception",
"}",
"in",
"nokeep",
"going",
"mode",
"!"
] |
[
"public",
"sky",
"value",
"compute",
"(",
"sky",
"key",
"sky",
"key",
",",
"environment",
"env",
")",
"throws",
"interrupted",
"exception",
"{",
"return",
"new",
"my",
"traversal",
"function",
"(",
")",
"visit",
"directory",
"(",
"(",
"recursive",
"pkg",
"key",
")",
"sky",
"key",
"argument",
"(",
")",
",",
"env",
")",
";",
"}"
] |
[
"load",
"envoy",
"rls",
"rules",
",",
"while",
"former",
"rules",
"will",
"be",
"replaced"
] |
[
"public",
"static",
"boolean",
"load",
"rules",
"(",
"list",
"<",
"envoy",
"rls",
"rule",
">",
"rules",
")",
"{",
"return",
"current",
"property",
"update",
"value",
"(",
"rules",
")",
";",
"}"
] |
[
"deserializes",
"from",
"{",
"@",
"code",
"coded",
"in",
"}",
",",
"inverse",
"of",
"{",
"@",
"link",
"#",
"serialize",
"}"
] |
[
"t",
"deserialize",
"(",
"deserialization",
"context",
"context",
",",
"coded",
"input",
"stream",
"coded",
"in",
")",
"throws",
"serialization",
"exception",
",",
"i",
"o",
"exception",
";"
] |
[
"return",
"a",
"{",
"@",
"link",
"resolvable",
"type",
"}",
"for",
"the",
"specified",
"{",
"@",
"link",
"type",
"}",
"backed",
"by",
"the",
"given",
"owner",
"type",
"note",
":",
"the",
"resulting",
"{",
"@",
"link",
"resolvable",
"type",
"}",
"instance",
"may",
"not",
"be",
"{",
"@",
"link",
"serializable",
"}"
] |
[
"public",
"static",
"resolvable",
"type",
"for",
"type",
"(",
"@",
"nullable",
"type",
"type",
",",
"@",
"nullable",
"resolvable",
"type",
"owner",
")",
"{",
"variable",
"resolver",
"variable",
"resolver",
"=",
"null",
";",
"if",
"(",
"owner",
"!",
"=",
"null",
")",
"{",
"variable",
"resolver",
"=",
"owner",
"as",
"variable",
"resolver",
"(",
")",
";",
"}",
"return",
"for",
"type",
"(",
"type",
",",
"variable",
"resolver",
")",
";",
"}"
] |
[
"topic",
"zipkin",
"spans",
"will",
"be",
"consumed",
"from",
"defaults",
"to",
"\"",
"zipkin",
"\"",
"multiple",
"topics",
"may",
"be",
"specified",
"if",
"comma",
"delimited"
] |
[
"public",
"builder",
"topic",
"(",
"string",
"topic",
")",
"{",
"if",
"(",
"topic",
"=",
"=",
"null",
")",
"throw",
"new",
"null",
"pointer",
"exception",
"(",
"\"",
"topic",
"=",
"=",
"null",
"\"",
")",
";",
"this",
"topic",
"=",
"topic",
";",
"return",
"this",
";",
"}"
] |
[
"returns",
"the",
"name",
"of",
"the",
"category"
] |
[
"public",
"string",
"get",
"category",
"name",
"(",
")",
"{",
"return",
"this",
"to",
"string",
"(",
")",
"to",
"lower",
"case",
"(",
")",
";",
"}"
] |
[
"set",
"the",
"object",
"where",
"the",
"render",
"function",
"belongs",
"(",
"optional",
")",
"for",
"example",
",",
"in",
"order",
"to",
"call",
"{",
"@",
"code",
"mustache",
"render",
"(",
")",
"}",
",",
"{",
"@",
"code",
"render",
"object",
"}",
"should",
"be",
"set",
"to",
"{",
"@",
"code",
"\"",
"mustache",
"\"",
"}",
"and",
"{",
"@",
"code",
"render",
"function",
"}",
"to",
"{",
"@",
"code",
"\"",
"render",
"\"",
"}"
] |
[
"public",
"void",
"set",
"render",
"object",
"(",
"@",
"nullable",
"string",
"render",
"object",
")",
"{",
"this",
"render",
"object",
"=",
"render",
"object",
";",
"}"
] |
[
"get",
"union",
"of",
"all",
"alts",
"from",
"configs"
] |
[
"public",
"static",
"bit",
"set",
"get",
"alts",
"(",
"a",
"t",
"n",
"config",
"set",
"configs",
")",
"{",
"bit",
"set",
"alts",
"=",
"new",
"bit",
"set",
"(",
")",
";",
"for",
"(",
"a",
"t",
"n",
"config",
"config",
":",
"configs",
")",
"{",
"alts",
"set",
"(",
"config",
"alt",
")",
";",
"}",
"return",
"alts",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"public",
"list",
"<",
"media",
"type",
">",
"resolve",
"media",
"types",
"(",
"native",
"web",
"request",
"request",
")",
"throws",
"http",
"media",
"type",
"not",
"acceptable",
"exception",
"{",
"string",
"[",
"]",
"header",
"value",
"array",
"=",
"request",
"get",
"header",
"values",
"(",
"http",
"headers",
"accept",
")",
";",
"if",
"(",
"header",
"value",
"array",
"=",
"=",
"null",
")",
"{",
"return",
"media",
"type",
"all",
"list",
";",
"}",
"list",
"<",
"string",
">",
"header",
"values",
"=",
"arrays",
"as",
"list",
"(",
"header",
"value",
"array",
")",
";",
"try",
"{",
"list",
"<",
"media",
"type",
">",
"media",
"types",
"=",
"media",
"type",
"parse",
"media",
"types",
"(",
"header",
"values",
")",
";",
"media",
"type",
"sort",
"by",
"specificity",
"and",
"quality",
"(",
"media",
"types",
")",
";",
"return",
"!",
"collection",
"utils",
"is",
"empty",
"(",
"media",
"types",
")",
"?",
"media",
"types",
":",
"media",
"type",
"all",
"list",
";",
"}",
"catch",
"(",
"invalid",
"media",
"type",
"exception",
"ex",
")",
"{",
"throw",
"new",
"http",
"media",
"type",
"not",
"acceptable",
"exception",
"(",
"\"",
"could",
"not",
"parse",
"'",
"accept",
"'",
"header",
"\"",
"+",
"header",
"values",
"+",
"\"",
":",
"\"",
"+",
"ex",
"get",
"message",
"(",
")",
")",
";",
"}",
"}"
] |
[
"stop",
"all",
"registered",
"beans",
"that",
"implement",
"{",
"@",
"link",
"lifecycle",
"}",
"and",
"are",
"currently",
"running",
"any",
"bean",
"that",
"implements",
"{",
"@",
"link",
"smart",
"lifecycle",
"}",
"will",
"be",
"stopped",
"within",
"its",
"'",
"phase",
"'",
",",
"and",
"all",
"phases",
"will",
"be",
"ordered",
"from",
"highest",
"to",
"lowest",
"value",
"all",
"beans",
"that",
"do",
"not",
"implement",
"{",
"@",
"link",
"smart",
"lifecycle",
"}",
"will",
"be",
"stopped",
"in",
"the",
"default",
"phase",
"0",
"a",
"bean",
"declared",
"as",
"dependent",
"on",
"another",
"bean",
"will",
"be",
"stopped",
"before",
"the",
"dependency",
"bean",
"regardless",
"of",
"the",
"declared",
"phase"
] |
[
"public",
"void",
"stop",
"(",
")",
"{",
"stop",
"beans",
"(",
")",
";",
"this",
"running",
"=",
"false",
";",
"}"
] |
[
"customize",
"request",
"specification"
] |
[
"public",
"update",
"pet",
"with",
"form",
"oper",
"req",
"spec",
"(",
"consumer",
"<",
"request",
"spec",
"builder",
">",
"req",
"spec",
"customizer",
")",
"{",
"req",
"spec",
"customizer",
"accept",
"(",
"req",
"spec",
")",
";",
"return",
"this",
";",
"}"
] |
[
"initialize",
"this",
"processor",
"with",
"the",
"given",
"context",
"the",
"framework",
"ensures",
"this",
"is",
"called",
"once",
"per",
"processor",
"when",
"the",
"topology",
"that",
"contains",
"it",
"is",
"initialized",
"when",
"the",
"framework",
"is",
"done",
"with",
"the",
"processor",
",",
"{",
"@",
"link",
"#",
"close",
"(",
")",
"}",
"will",
"be",
"called",
"on",
"it",
";",
"the",
"framework",
"may",
"later",
"re",
"-",
"use",
"the",
"processor",
"by",
"calling",
"{",
"@",
"code",
"#",
"init",
"(",
")",
"}",
"again",
"the",
"provided",
"{",
"@",
"link",
"processor",
"context",
"context",
"}",
"can",
"be",
"used",
"to",
"access",
"topology",
"and",
"record",
"meta",
"data",
",",
"to",
"{",
"@",
"link",
"processor",
"context",
"#",
"schedule",
"(",
"duration",
",",
"punctuation",
"type",
",",
"punctuator",
")",
"schedule",
"}",
"a",
"method",
"to",
"be",
"{",
"@",
"link",
"punctuator",
"#",
"punctuate",
"(",
"long",
")",
"called",
"periodically",
"}",
"and",
"to",
"access",
"attached",
"{",
"@",
"link",
"state",
"store",
"}",
"s"
] |
[
"default",
"void",
"init",
"(",
"final",
"processor",
"context",
"<",
"k",
"out",
",",
"v",
"out",
">",
"context",
")",
"{",
"}"
] |
[
"mockito",
"attempts",
"to",
"use",
"constructor",
"when",
"creating",
"instance",
"of",
"the",
"mock",
"this",
"is",
"particularly",
"useful",
"for",
"spying",
"on",
"abstract",
"classes",
"see",
"also",
"{",
"@",
"link",
"mockito",
"#",
"spy",
"(",
"class",
")",
"}",
"example",
":",
"<",
"pre",
"class",
"=",
"\"",
"code",
"\"",
">",
"<",
"code",
"class",
"=",
"\"",
"java",
"\"",
">",
"robust",
"api",
",",
"via",
"settings",
"builder",
":",
"other",
"abstract",
"spy",
"=",
"mock",
"(",
"other",
"abstract",
"class",
",",
"with",
"settings",
"(",
")",
"use",
"constructor",
"(",
")",
"default",
"answer",
"(",
"calls",
"real",
"methods",
")",
")",
";",
"mocking",
"an",
"abstract",
"class",
"with",
"constructor",
"arguments",
"some",
"abstract",
"spy",
"=",
"mock",
"(",
"some",
"abstract",
"class",
",",
"with",
"settings",
"(",
")",
"use",
"constructor",
"(",
"\"",
"arg",
"1",
"\"",
",",
"123",
")",
"default",
"answer",
"(",
"calls",
"real",
"methods",
")",
")",
";",
"mocking",
"a",
"non",
"-",
"static",
"inner",
"abstract",
"class",
":",
"inner",
"abstract",
"spy",
"=",
"mock",
"(",
"inner",
"abstract",
"class",
",",
"with",
"settings",
"(",
")",
"use",
"constructor",
"(",
")",
"outer",
"instance",
"(",
"outer",
"instance",
")",
"default",
"answer",
"(",
"calls",
"real",
"methods",
")",
")",
";",
"<",
"code",
">"
] |
[
"mock",
"settings",
"use",
"constructor",
"(",
"object",
"args",
")",
";"
] |
[
"get",
"integer",
"minimum",
":",
"10",
"maximum",
":",
"100"
] |
[
"public",
"integer",
"get",
"integer",
"(",
")",
"{",
"return",
"integer",
";",
"}"
] |
[
"configure",
"a",
"{",
"@",
"link",
"list",
"}",
"of",
"{",
"@",
"link",
"docking",
"action",
"if",
"}",
"to",
"provide",
"to",
"the",
"{",
"@",
"link",
"multi",
"action",
"docking",
"action",
"}"
] |
[
"public",
"multi",
"action",
"builder",
"with",
"actions",
"(",
"list",
"<",
"docking",
"action",
"if",
">",
"list",
")",
"{",
"this",
"action",
"list",
"=",
"list",
";",
"for",
"(",
"docking",
"action",
"if",
"action",
":",
"action",
"list",
")",
"{",
"if",
"(",
"action",
"get",
"menu",
"bar",
"data",
"(",
")",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"actions",
"in",
"the",
"action",
"list",
"must",
"have",
"menu",
"bar",
"data",
"defined",
"\"",
")",
";",
"}",
"}",
"return",
"self",
"(",
")",
";",
"}"
] |
[
"create",
"an",
"invalid",
"committer",
"via",
"the",
"fs",
"binding",
","
] |
[
"public",
"void",
"test",
"invalid",
"file",
"binding",
"(",
")",
"throws",
"throwable",
"{",
"task",
"conf",
"ref",
"unset",
"(",
"fs",
"s3a",
"committer",
"name",
")",
";",
"filesystem",
"conf",
"ref",
"set",
"(",
"fs",
"s3a",
"committer",
"name",
",",
"invalid",
"name",
")",
";",
"lambda",
"test",
"utils",
"intercept",
"(",
"path",
"commit",
"exception",
"class",
",",
"invalid",
"name",
",",
"(",
")",
"-",
">",
"create",
"committer",
"(",
")",
")",
";",
"}"
] |
[
"get",
"the",
"number",
"of",
"triangles",
"containing",
"this",
"vertex",
";",
"equivalently",
",",
"this",
"is",
"the",
"number",
"of",
"edges",
"between",
"neighbors",
"of",
"this",
"vertex"
] |
[
"public",
"long",
"value",
"get",
"triangle",
"count",
"(",
")",
"{",
"return",
"triangle",
"count",
";",
"}"
] |
[
"lazily",
"converts",
"artifacts",
"into",
"root",
"-",
"relative",
"path",
"strings",
"middleman",
"artifacts",
"are",
"ignored",
"by",
"this",
"method"
] |
[
"public",
"static",
"iterable",
"<",
"string",
">",
"to",
"root",
"relative",
"paths",
"(",
"iterable",
"<",
"artifact",
">",
"artifacts",
")",
"{",
"return",
"iterables",
"transform",
"(",
"iterables",
"filter",
"(",
"artifacts",
",",
"middleman",
"filter",
")",
",",
"artifact",
"-",
">",
"artifact",
"get",
"root",
"relative",
"path",
"(",
")",
"get",
"path",
"string",
"(",
")",
")",
";",
"}"
] |
[
"returns",
"a",
"{",
"@",
"link",
"protocol",
"detection",
"result",
"}",
"which",
"holds",
"the",
"detected",
"protocol"
] |
[
"public",
"static",
"<",
"t",
">",
"protocol",
"detection",
"result",
"<",
"t",
">",
"detected",
"(",
"t",
"protocol",
")",
"{",
"return",
"new",
"protocol",
"detection",
"result",
"<",
"t",
">",
"(",
"protocol",
"detection",
"state",
"detected",
",",
"check",
"not",
"null",
"(",
"protocol",
",",
"\"",
"protocol",
"\"",
")",
")",
";",
"}"
] |
[
"returns",
"the",
"short",
"value",
"for",
"the",
"given",
"key",
"if",
"the",
"key",
"does",
"not",
"exists",
"it",
"will",
"return",
"the",
"default",
"value",
"given",
"the",
"method",
"fails",
"if",
"the",
"value",
"is",
"not",
"a",
"short"
] |
[
"public",
"short",
"get",
"short",
"(",
"string",
"key",
",",
"short",
"default",
"value",
")",
"{",
"add",
"to",
"defaults",
"(",
"key",
",",
"short",
"to",
"string",
"(",
"default",
"value",
")",
")",
";",
"string",
"value",
"=",
"get",
"(",
"key",
")",
";",
"if",
"(",
"value",
"=",
"=",
"null",
")",
"{",
"return",
"default",
"value",
";",
"}",
"else",
"{",
"return",
"short",
"value",
"of",
"(",
"value",
")",
";",
"}",
"}"
] |
[
"called",
"when",
"a",
"list",
"is",
"mutated"
] |
[
"protected",
"void",
"on",
"modified",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"try",
"{",
"owner",
"save",
"(",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"x",
")",
"{",
"optional",
"<",
"t",
">",
"ignored",
"=",
"stream",
"(",
")",
"filter",
"(",
"persisted",
"list",
":",
":",
"ignore",
"serialization",
"errors",
")",
"find",
"any",
"(",
")",
";",
"if",
"(",
"ignored",
"is",
"present",
"(",
")",
")",
"{",
"logger",
"log",
"(",
"level",
"warning",
",",
"\"",
"ignoring",
"serialization",
"errors",
"in",
"\"",
"+",
"ignored",
"get",
"(",
")",
"+",
"\"",
";",
"update",
"your",
"parent",
"pom",
"to",
"4",
"8",
"or",
"newer",
"\"",
",",
"x",
")",
";",
"}",
"else",
"{",
"throw",
"x",
";",
"}",
"}",
"}"
] |
[
"initializes",
"the",
"registered",
"service",
"with",
"default",
"values",
"for",
"fields",
"that",
"are",
"unspecified",
"only",
"triggered",
"by",
"jpa"
] |
[
"public",
"void",
"initialize",
"(",
")",
"{",
"set",
"canonicalization",
"mode",
"(",
"case",
"canonicalization",
"mode",
"none",
"name",
"(",
")",
")",
";",
"}"
] |
[
"stop",
"the",
"periodic",
"task"
] |
[
"protected",
"synchronized",
"void",
"stop",
"periodic",
"(",
")",
"{",
"if",
"(",
"this",
"is",
"running",
")",
"{",
"log",
"info",
"(",
"\"",
"{",
"}",
"is",
"shutting",
"down",
"\"",
",",
"this",
"service",
"name",
")",
";",
"this",
"is",
"running",
"=",
"false",
";",
"this",
"scheduler",
"shutdown",
"now",
"(",
")",
";",
"}",
"}"
] |
[
"the",
"security",
"manager",
"can",
"be",
"disabled",
"by",
"the",
"test",
"runner",
"(",
"or",
"any",
"other",
"class",
"in",
"the",
"same",
"package",
")",
"to",
"allow",
"it",
"to",
"exit",
"with",
"a",
"meaningful",
"result",
"code",
"visible",
"for",
"testing"
] |
[
"synchronized",
"void",
"set",
"enabled",
"(",
"boolean",
"enabled",
")",
"{",
"this",
"enabled",
"=",
"enabled",
";",
"}"
] |
[
"handle",
"the",
"given",
"request"
] |
[
"protected",
"boolean",
"handle",
"internal",
"(",
"server",
"http",
"request",
"request",
",",
"server",
"http",
"response",
"response",
",",
"cors",
"configuration",
"config",
",",
"boolean",
"pre",
"flight",
"request",
")",
"throws",
"i",
"o",
"exception",
"{",
"string",
"request",
"origin",
"=",
"request",
"get",
"headers",
"(",
")",
"get",
"origin",
"(",
")",
";",
"string",
"allow",
"origin",
"=",
"check",
"origin",
"(",
"config",
",",
"request",
"origin",
")",
";",
"http",
"headers",
"response",
"headers",
"=",
"response",
"get",
"headers",
"(",
")",
";",
"if",
"(",
"allow",
"origin",
"=",
"=",
"null",
")",
"{",
"logger",
"debug",
"(",
"\"",
"reject",
":",
"'",
"\"",
"+",
"request",
"origin",
"+",
"\"",
"'",
"origin",
"is",
"not",
"allowed",
"\"",
")",
";",
"reject",
"request",
"(",
"response",
")",
";",
"return",
"false",
";",
"}",
"http",
"method",
"request",
"method",
"=",
"get",
"method",
"to",
"use",
"(",
"request",
",",
"pre",
"flight",
"request",
")",
";",
"list",
"<",
"http",
"method",
">",
"allow",
"methods",
"=",
"check",
"methods",
"(",
"config",
",",
"request",
"method",
")",
";",
"if",
"(",
"allow",
"methods",
"=",
"=",
"null",
")",
"{",
"logger",
"debug",
"(",
"\"",
"reject",
":",
"http",
"'",
"\"",
"+",
"request",
"method",
"+",
"\"",
"'",
"is",
"not",
"allowed",
"\"",
")",
";",
"reject",
"request",
"(",
"response",
")",
";",
"return",
"false",
";",
"}",
"list",
"<",
"string",
">",
"request",
"headers",
"=",
"get",
"headers",
"to",
"use",
"(",
"request",
",",
"pre",
"flight",
"request",
")",
";",
"list",
"<",
"string",
">",
"allow",
"headers",
"=",
"check",
"headers",
"(",
"config",
",",
"request",
"headers",
")",
";",
"if",
"(",
"pre",
"flight",
"request",
"&",
"&",
"allow",
"headers",
"=",
"=",
"null",
")",
"{",
"logger",
"debug",
"(",
"\"",
"reject",
":",
"headers",
"'",
"\"",
"+",
"request",
"headers",
"+",
"\"",
"'",
"are",
"not",
"allowed",
"\"",
")",
";",
"reject",
"request",
"(",
"response",
")",
";",
"return",
"false",
";",
"}",
"response",
"headers",
"set",
"access",
"control",
"allow",
"origin",
"(",
"allow",
"origin",
")",
";",
"if",
"(",
"pre",
"flight",
"request",
")",
"{",
"response",
"headers",
"set",
"access",
"control",
"allow",
"methods",
"(",
"allow",
"methods",
")",
";",
"}",
"if",
"(",
"pre",
"flight",
"request",
"&",
"&",
"!",
"allow",
"headers",
"is",
"empty",
"(",
")",
")",
"{",
"response",
"headers",
"set",
"access",
"control",
"allow",
"headers",
"(",
"allow",
"headers",
")",
";",
"}",
"if",
"(",
"!",
"collection",
"utils",
"is",
"empty",
"(",
"config",
"get",
"exposed",
"headers",
"(",
")",
")",
")",
"{",
"response",
"headers",
"set",
"access",
"control",
"expose",
"headers",
"(",
"config",
"get",
"exposed",
"headers",
"(",
")",
")",
";",
"}",
"if",
"(",
"boolean",
"true",
"equals",
"(",
"config",
"get",
"allow",
"credentials",
"(",
")",
")",
")",
"{",
"response",
"headers",
"set",
"access",
"control",
"allow",
"credentials",
"(",
"true",
")",
";",
"}",
"if",
"(",
"pre",
"flight",
"request",
"&",
"&",
"config",
"get",
"max",
"age",
"(",
")",
"!",
"=",
"null",
")",
"{",
"response",
"headers",
"set",
"access",
"control",
"max",
"age",
"(",
"config",
"get",
"max",
"age",
"(",
")",
")",
";",
"}",
"response",
"flush",
"(",
")",
";",
"return",
"true",
";",
"}"
] |
[
"check",
"that",
"we",
"haven",
"'",
"t",
"hit",
"a",
"run",
"of",
"the",
"same",
"exact",
"instruction",
"uses",
"hashcodes",
"in",
"an",
"attempt",
"to",
"be",
"as",
"fast",
"as",
"possible"
] |
[
"private",
"boolean",
"check",
"same",
"instruction",
"run",
"(",
"instruction",
"instr",
")",
"{",
"if",
"(",
"last",
"instr",
"code",
"=",
"=",
"instr",
"get",
"prototype",
"(",
")",
"hash",
"code",
"(",
")",
")",
"{",
"/",
"/",
"allow",
"same",
"prototype",
"once",
",",
"before",
"starting",
"to",
"get",
"bytes",
"and",
"do",
"careful",
"check",
"if",
"(",
"last",
"full",
"hash",
"code",
"=",
"=",
"0",
")",
"{",
"last",
"full",
"hash",
"code",
"=",
"-",
"1",
";",
"}",
"else",
"{",
"int",
"instr",
"byte",
"hash",
"code",
"=",
"-",
"1",
";",
"try",
"{",
"instr",
"byte",
"hash",
"code",
"=",
"arrays",
"hash",
"code",
"(",
"instr",
"get",
"bytes",
"(",
")",
")",
";",
"}",
"catch",
"(",
"memory",
"access",
"exception",
"e",
")",
"{",
"/",
"/",
"this",
"should",
"never",
"happen",
",",
"should",
"always",
"be",
"able",
"to",
"get",
"the",
"bytes",
"instr",
"byte",
"hash",
"code",
"=",
"instr",
"to",
"string",
"(",
")",
"hash",
"code",
"(",
")",
";",
"}",
"if",
"(",
"last",
"full",
"hash",
"code",
"=",
"=",
"-",
"1",
")",
"{",
"last",
"full",
"hash",
"code",
"=",
"instr",
"byte",
"hash",
"code",
";",
"}",
"if",
"(",
"last",
"full",
"hash",
"code",
"=",
"=",
"instr",
"byte",
"hash",
"code",
")",
"{",
"same",
"instr",
"count",
"+",
"+",
";",
"if",
"(",
"same",
"instr",
"count",
">",
"max",
"exact",
"instructions",
")",
"{",
"return",
"true",
";",
"}",
"}",
"else",
"{",
"/",
"/",
"isn",
"'",
"t",
"exactly",
"the",
"same",
"last",
"full",
"hash",
"code",
"=",
"0",
";",
"same",
"instr",
"count",
"=",
"0",
";",
"}",
"}",
"}",
"else",
"{",
"/",
"/",
"isn",
"'",
"t",
"exactly",
"the",
"same",
"same",
"instr",
"count",
"=",
"0",
";",
"last",
"full",
"hash",
"code",
"=",
"0",
";",
"}",
"last",
"instr",
"code",
"=",
"instr",
"get",
"prototype",
"(",
")",
"hash",
"code",
"(",
")",
";",
"return",
"false",
";",
"}"
] |
[
"checks",
"that",
"all",
"shard",
"requests",
"of",
"a",
"replicated",
"broadcast",
"request",
"failed",
"due",
"to",
"a",
"cluster",
"block"
] |
[
"public",
"static",
"void",
"assert",
"blocked",
"(",
"broadcast",
"response",
"replicated",
"broadcast",
"response",
")",
"{",
"assert",
"that",
"(",
"\"",
"all",
"shard",
"requests",
"should",
"have",
"failed",
"\"",
",",
"replicated",
"broadcast",
"response",
"get",
"failed",
"shards",
"(",
")",
",",
"equal",
"to",
"(",
"replicated",
"broadcast",
"response",
"get",
"total",
"shards",
"(",
")",
")",
")",
";",
"for",
"(",
"default",
"shard",
"operation",
"failed",
"exception",
"exception",
":",
"replicated",
"broadcast",
"response",
"get",
"shard",
"failures",
"(",
")",
")",
"{",
"cluster",
"block",
"exception",
"cluster",
"block",
"exception",
"=",
"(",
"cluster",
"block",
"exception",
")",
"exceptions",
"helper",
"unwrap",
"(",
"exception",
"get",
"cause",
"(",
")",
",",
"cluster",
"block",
"exception",
"class",
")",
";",
"assert",
"not",
"null",
"(",
"\"",
"expected",
"the",
"cause",
"of",
"failure",
"to",
"be",
"a",
"cluster",
"block",
"exception",
"but",
"got",
"\"",
"+",
"exception",
"get",
"cause",
"(",
")",
"get",
"message",
"(",
")",
",",
"cluster",
"block",
"exception",
")",
";",
"assert",
"that",
"(",
"cluster",
"block",
"exception",
"blocks",
"(",
")",
"size",
"(",
")",
",",
"greater",
"than",
"(",
"0",
")",
")",
";",
"rest",
"status",
"status",
"=",
"check",
"retryable",
"block",
"(",
"cluster",
"block",
"exception",
"blocks",
"(",
")",
")",
"?",
"rest",
"status",
"too",
"many",
"requests",
":",
"rest",
"status",
"forbidden",
";",
"assert",
"that",
"(",
"cluster",
"block",
"exception",
"status",
"(",
")",
",",
"core",
"matchers",
"equal",
"to",
"(",
"status",
")",
")",
";",
"}",
"}"
] |
[
"customize",
"the",
"set",
"of",
"{",
"@",
"link",
"property",
"source",
"}",
"objects",
"to",
"be",
"searched",
"by",
"this",
"{",
"@",
"code",
"environment",
"}",
"during",
"calls",
"to",
"{",
"@",
"link",
"#",
"get",
"property",
"(",
"string",
")",
"}",
"and",
"related",
"methods",
"subclasses",
"that",
"override",
"this",
"method",
"are",
"encouraged",
"to",
"add",
"property",
"sources",
"using",
"{",
"@",
"link",
"mutable",
"property",
"sources",
"#",
"add",
"last",
"(",
"property",
"source",
")",
"}",
"such",
"that",
"further",
"subclasses",
"may",
"call",
"{",
"@",
"code",
"super",
"customize",
"property",
"sources",
"(",
")",
"}",
"with",
"predictable",
"results",
"for",
"example",
":",
"<",
"pre",
"class",
"=",
"\"",
"code",
"\"",
">",
"public",
"class",
"level",
"1",
"environment",
"extends",
"abstract",
"environment",
"{",
"&",
"#",
"064",
";",
"override",
"protected",
"void",
"customize",
"property",
"sources",
"(",
"mutable",
"property",
"sources",
"property",
"sources",
")",
"{",
"super",
"customize",
"property",
"sources",
"(",
"property",
"sources",
")",
";",
"no",
"-",
"op",
"from",
"base",
"class",
"property",
"sources",
"add",
"last",
"(",
"new",
"property",
"source",
"a",
"(",
")",
")",
";",
"property",
"sources",
"add",
"last",
"(",
"new",
"property",
"source",
"b",
"(",
")",
")",
";",
"}",
"}",
"public",
"class",
"level",
"2",
"environment",
"extends",
"level",
"1",
"environment",
"{",
"&",
"#",
"064",
";",
"override",
"protected",
"void",
"customize",
"property",
"sources",
"(",
"mutable",
"property",
"sources",
"property",
"sources",
")",
"{",
"super",
"customize",
"property",
"sources",
"(",
"property",
"sources",
")",
";",
"add",
"all",
"from",
"superclass",
"property",
"sources",
"add",
"last",
"(",
"new",
"property",
"source",
"c",
"(",
")",
")",
";",
"property",
"sources",
"add",
"last",
"(",
"new",
"property",
"source",
"d",
"(",
")",
")",
";",
"}",
"}",
"in",
"this",
"arrangement",
",",
"properties",
"will",
"be",
"resolved",
"against",
"sources",
"a",
",",
"b",
",",
"c",
",",
"d",
"in",
"that",
"order",
"that",
"is",
"to",
"say",
"that",
"property",
"source",
"\"",
"a",
"\"",
"has",
"precedence",
"over",
"property",
"source",
"\"",
"d",
"\"",
"if",
"the",
"{",
"@",
"code",
"level",
"2",
"environment",
"}",
"subclass",
"wished",
"to",
"give",
"property",
"sources",
"c",
"and",
"d",
"higher",
"precedence",
"than",
"a",
"and",
"b",
",",
"it",
"could",
"simply",
"call",
"{",
"@",
"code",
"super",
"customize",
"property",
"sources",
"}",
"after",
",",
"rather",
"than",
"before",
"adding",
"its",
"own",
":",
"<",
"pre",
"class",
"=",
"\"",
"code",
"\"",
">",
"public",
"class",
"level",
"2",
"environment",
"extends",
"level",
"1",
"environment",
"{",
"&",
"#",
"064",
";",
"override",
"protected",
"void",
"customize",
"property",
"sources",
"(",
"mutable",
"property",
"sources",
"property",
"sources",
")",
"{",
"property",
"sources",
"add",
"last",
"(",
"new",
"property",
"source",
"c",
"(",
")",
")",
";",
"property",
"sources",
"add",
"last",
"(",
"new",
"property",
"source",
"d",
"(",
")",
")",
";",
"super",
"customize",
"property",
"sources",
"(",
"property",
"sources",
")",
";",
"add",
"all",
"from",
"superclass",
"}",
"}",
"the",
"search",
"order",
"is",
"now",
"c",
",",
"d",
",",
"a",
",",
"b",
"as",
"desired",
"beyond",
"these",
"recommendations",
",",
"subclasses",
"may",
"use",
"any",
"of",
"the",
"{",
"@",
"code",
"add",
"&",
"#",
"42",
";",
"}",
",",
"{",
"@",
"code",
"remove",
"}",
",",
"or",
"{",
"@",
"code",
"replace",
"}",
"methods",
"exposed",
"by",
"{",
"@",
"link",
"mutable",
"property",
"sources",
"}",
"in",
"order",
"to",
"create",
"the",
"exact",
"arrangement",
"of",
"property",
"sources",
"desired",
"the",
"base",
"implementation",
"registers",
"no",
"property",
"sources",
"note",
"that",
"clients",
"of",
"any",
"{",
"@",
"link",
"configurable",
"environment",
"}",
"may",
"further",
"customize",
"property",
"sources",
"via",
"the",
"{",
"@",
"link",
"#",
"get",
"property",
"sources",
"(",
")",
"}",
"accessor",
",",
"typically",
"within",
"an",
"{",
"@",
"link",
"org",
"springframework",
"context",
"application",
"context",
"initializer",
"application",
"context",
"initializer",
"}",
"for",
"example",
":",
"<",
"pre",
"class",
"=",
"\"",
"code",
"\"",
">",
"configurable",
"environment",
"env",
"=",
"new",
"standard",
"environment",
"(",
")",
";",
"env",
"get",
"property",
"sources",
"(",
")",
"add",
"last",
"(",
"new",
"property",
"source",
"x",
"(",
")",
")",
";",
"<",
"h",
"2",
">",
"a",
"warning",
"about",
"instance",
"variable",
"access",
"<",
"h",
"2",
">",
"instance",
"variables",
"declared",
"in",
"subclasses",
"and",
"having",
"default",
"initial",
"values",
"should",
"not",
"be",
"accessed",
"from",
"within",
"this",
"method",
"due",
"to",
"java",
"object",
"creation",
"lifecycle",
"constraints",
",",
"any",
"initial",
"value",
"will",
"not",
"yet",
"be",
"assigned",
"when",
"this",
"callback",
"is",
"invoked",
"by",
"the",
"{",
"@",
"link",
"#",
"abstract",
"environment",
"(",
")",
"}",
"constructor",
",",
"which",
"may",
"lead",
"to",
"a",
"{",
"@",
"code",
"null",
"pointer",
"exception",
"}",
"or",
"other",
"problems",
"if",
"you",
"need",
"to",
"access",
"default",
"values",
"of",
"instance",
"variables",
",",
"leave",
"this",
"method",
"as",
"a",
"no",
"-",
"op",
"and",
"perform",
"property",
"source",
"manipulation",
"and",
"instance",
"variable",
"access",
"directly",
"within",
"the",
"subclass",
"constructor",
"note",
"that",
"assigning",
"values",
"to",
"instance",
"variables",
"is",
"not",
"problematic",
";",
"it",
"is",
"only",
"attempting",
"to",
"read",
"default",
"values",
"that",
"must",
"be",
"avoided"
] |
[
"protected",
"void",
"customize",
"property",
"sources",
"(",
"mutable",
"property",
"sources",
"property",
"sources",
")",
"{",
"}"
] |
[
"returns",
"the",
"long",
"at",
"<",
"code",
">",
"index",
"<",
"code",
">"
] |
[
"public",
"long",
"read",
"long",
"(",
"long",
"index",
",",
"long",
"min",
"clamp",
",",
"long",
"max",
"clamp",
",",
"long",
"exceptions",
")",
"throws",
"i",
"o",
"exception",
"{",
"long",
"l",
"=",
"read",
"long",
"(",
"index",
")",
";",
"return",
"clamp",
"long",
"(",
"l",
",",
"min",
"clamp",
",",
"max",
"clamp",
",",
"exceptions",
")",
";",
"}"
] |
[
"uses",
"method",
"and",
"type",
"-",
"level",
"@",
"{",
"@",
"link",
"request",
"mapping",
"}",
"annotations",
"to",
"create",
"the",
"request",
"mapping",
"info"
] |
[
"protected",
"request",
"mapping",
"info",
"get",
"mapping",
"for",
"method",
"(",
"method",
"method",
",",
"class",
"<",
"?",
">",
"handler",
"type",
")",
"{",
"request",
"mapping",
"info",
"info",
"=",
"create",
"request",
"mapping",
"info",
"(",
"method",
")",
";",
"if",
"(",
"info",
"!",
"=",
"null",
")",
"{",
"request",
"mapping",
"info",
"type",
"info",
"=",
"create",
"request",
"mapping",
"info",
"(",
"handler",
"type",
")",
";",
"if",
"(",
"type",
"info",
"!",
"=",
"null",
")",
"{",
"info",
"=",
"type",
"info",
"combine",
"(",
"info",
")",
";",
"}",
"string",
"prefix",
"=",
"get",
"path",
"prefix",
"(",
"handler",
"type",
")",
";",
"if",
"(",
"prefix",
"!",
"=",
"null",
")",
"{",
"info",
"=",
"request",
"mapping",
"info",
"paths",
"(",
"prefix",
")",
"options",
"(",
"this",
"config",
")",
"build",
"(",
")",
"combine",
"(",
"info",
")",
";",
"}",
"}",
"return",
"info",
";",
"}"
] |
[
"check",
"whether",
"a",
"service",
"id",
"was",
"passed",
"in"
] |
[
"private",
"string",
"try",
"get",
"bean",
"name",
"(",
"@",
"nullable",
"object",
"[",
"]",
"args",
")",
"{",
"string",
"bean",
"name",
"=",
"\"",
"\"",
";",
"if",
"(",
"args",
"!",
"=",
"null",
"&",
"&",
"args",
"length",
"=",
"=",
"1",
"&",
"&",
"args",
"[",
"0",
"]",
"!",
"=",
"null",
")",
"{",
"bean",
"name",
"=",
"args",
"[",
"0",
"]",
"to",
"string",
"(",
")",
";",
"}",
"/",
"/",
"look",
"for",
"explicit",
"service",
"id",
"-",
"to",
"-",
"bean",
"name",
"mappings",
"if",
"(",
"service",
"mappings",
"!",
"=",
"null",
")",
"{",
"string",
"mapped",
"name",
"=",
"service",
"mappings",
"get",
"property",
"(",
"bean",
"name",
")",
";",
"if",
"(",
"mapped",
"name",
"!",
"=",
"null",
")",
"{",
"bean",
"name",
"=",
"mapped",
"name",
";",
"}",
"}",
"return",
"bean",
"name",
";",
"}"
] |
[
"given",
"a",
"string",
"representation",
"of",
"a",
"node",
",",
"return",
"its",
"reference"
] |
[
"public",
"node",
"get",
"node",
"(",
"string",
"loc",
")",
"{",
"netlock",
"read",
"lock",
"(",
")",
"lock",
"(",
")",
";",
"try",
"{",
"loc",
"=",
"node",
"base",
"normalize",
"(",
"loc",
")",
";",
"if",
"(",
"!",
"node",
"base",
"root",
"equals",
"(",
"loc",
")",
")",
"loc",
"=",
"loc",
"substring",
"(",
"1",
")",
";",
"return",
"cluster",
"map",
"get",
"loc",
"(",
"loc",
")",
";",
"}",
"finally",
"{",
"netlock",
"read",
"lock",
"(",
")",
"unlock",
"(",
")",
";",
"}",
"}"
] |
[
"either",
"this",
"or",
"{",
"@",
"link",
"#",
"inject",
"}",
"needs",
"to",
"be",
"overridden"
] |
[
"protected",
"object",
"get",
"resource",
"to",
"inject",
"(",
"object",
"target",
",",
"@",
"nullable",
"string",
"requesting",
"bean",
"name",
")",
"{",
"return",
"null",
";",
"}"
] |
[
"model",
"tests",
"for",
"array",
"of",
"array",
"of",
"number",
"only"
] |
[
"public",
"void",
"test",
"array",
"of",
"array",
"of",
"number",
"only",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"array",
"of",
"array",
"of",
"number",
"only",
"}"
] |
[
"adds",
"a",
"mapper",
"class",
"to",
"the",
"chain",
"job",
"'",
"s",
"job",
"conf",
"<",
"p",
">",
"the",
"configuration",
"properties",
"of",
"the",
"chain",
"job",
"have",
"precedence",
"over",
"the",
"configuration",
"properties",
"of",
"the",
"mapper"
] |
[
"public",
"static",
"<",
"k1",
",",
"v1",
",",
"k2",
",",
"v2",
">",
"void",
"add",
"mapper",
"(",
"boolean",
"is",
"map",
",",
"job",
"conf",
"job",
"conf",
",",
"class",
"<",
"?",
"extends",
"mapper",
"<",
"k1",
",",
"v1",
",",
"k2",
",",
"v2",
">",
">",
"klass",
",",
"class",
"<",
"?",
"extends",
"k1",
">",
"input",
"key",
"class",
",",
"class",
"<",
"?",
"extends",
"v1",
">",
"input",
"value",
"class",
",",
"class",
"<",
"?",
"extends",
"k2",
">",
"output",
"key",
"class",
",",
"class",
"<",
"?",
"extends",
"v2",
">",
"output",
"value",
"class",
",",
"boolean",
"by",
"value",
",",
"job",
"conf",
"mapper",
"conf",
")",
"{",
"string",
"prefix",
"=",
"get",
"prefix",
"(",
"is",
"map",
")",
";",
"/",
"/",
"if",
"a",
"reducer",
"chain",
"check",
"the",
"reducer",
"has",
"been",
"already",
"set",
"check",
"reducer",
"already",
"set",
"(",
"is",
"map",
",",
"job",
"conf",
",",
"prefix",
",",
"true",
")",
";",
"/",
"/",
"set",
"the",
"mapper",
"class",
"int",
"index",
"=",
"get",
"index",
"(",
"job",
"conf",
",",
"prefix",
")",
";",
"job",
"conf",
"set",
"class",
"(",
"prefix",
"+",
"chain",
"mapper",
"class",
"+",
"index",
",",
"klass",
",",
"mapper",
"class",
")",
";",
"validate",
"key",
"value",
"types",
"(",
"is",
"map",
",",
"job",
"conf",
",",
"input",
"key",
"class",
",",
"input",
"value",
"class",
",",
"output",
"key",
"class",
",",
"output",
"value",
"class",
",",
"index",
",",
"prefix",
")",
";",
"/",
"/",
"if",
"the",
"mapper",
"does",
"not",
"have",
"a",
"private",
"job",
"conf",
"create",
"an",
"empty",
"one",
"if",
"(",
"mapper",
"conf",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"using",
"a",
"job",
"conf",
"without",
"defaults",
"to",
"make",
"it",
"lightweight",
"/",
"/",
"still",
"the",
"chain",
"job",
"conf",
"may",
"have",
"all",
"defaults",
"and",
"this",
"conf",
"is",
"/",
"/",
"overlapped",
"to",
"the",
"chain",
"job",
"conf",
"one",
"mapper",
"conf",
"=",
"new",
"job",
"conf",
"(",
"true",
")",
";",
"}",
"/",
"/",
"store",
"in",
"the",
"private",
"mapper",
"conf",
"if",
"it",
"works",
"by",
"value",
"or",
"by",
"reference",
"mapper",
"conf",
"set",
"boolean",
"(",
"mapper",
"by",
"value",
",",
"by",
"value",
")",
";",
"set",
"mapper",
"conf",
"(",
"is",
"map",
",",
"job",
"conf",
",",
"input",
"key",
"class",
",",
"input",
"value",
"class",
",",
"output",
"key",
"class",
",",
"output",
"value",
"class",
",",
"mapper",
"conf",
",",
"index",
",",
"prefix",
")",
";",
"}"
] |
[
"tests",
"corruption",
"that",
"happens",
"on",
"a",
"single",
"shard",
"when",
"no",
"replicas",
"are",
"present",
"we",
"make",
"sure",
"that",
"the",
"primary",
"stays",
"unassigned",
"and",
"all",
"other",
"replicas",
"for",
"the",
"healthy",
"shards",
"happens"
] |
[
"public",
"void",
"test",
"corrupt",
"primary",
"no",
"replica",
"(",
")",
"throws",
"execution",
"exception",
",",
"interrupted",
"exception",
",",
"i",
"o",
"exception",
"{",
"int",
"num",
"docs",
"=",
"scaled",
"random",
"int",
"between",
"(",
"100",
",",
"1000",
")",
";",
"internal",
"cluster",
"(",
")",
"ensure",
"at",
"least",
"num",
"data",
"nodes",
"(",
"2",
")",
";",
"assert",
"acked",
"(",
"prepare",
"create",
"(",
"\"",
"test",
"\"",
")",
"set",
"settings",
"(",
"settings",
"builder",
"(",
")",
"put",
"(",
"index",
"metadata",
"setting",
"number",
"of",
"replicas",
",",
"\"",
"0",
"\"",
")",
"put",
"(",
"merge",
"policy",
"config",
"index",
"merge",
"enabled",
",",
"false",
")",
"put",
"(",
"mock",
"f",
"s",
"index",
"store",
"index",
"check",
"index",
"on",
"close",
"setting",
"get",
"key",
"(",
")",
",",
"false",
")",
"/",
"/",
"no",
"checkindex",
"-",
"we",
"corrupt",
"shards",
"on",
"purpose",
"/",
"/",
"no",
"translog",
"based",
"flush",
"-",
"it",
"might",
"change",
"the",
"liv",
"/",
"segments",
"n",
"files",
"put",
"(",
"index",
"settings",
"index",
"translog",
"flush",
"threshold",
"size",
"setting",
"get",
"key",
"(",
")",
",",
"new",
"byte",
"size",
"value",
"(",
"1",
",",
"byte",
"size",
"unit",
"pb",
")",
")",
")",
")",
";",
"ensure",
"green",
"(",
")",
";",
"index",
"request",
"builder",
"[",
"]",
"builders",
"=",
"new",
"index",
"request",
"builder",
"[",
"num",
"docs",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"builders",
"length",
";",
"i",
"+",
"+",
")",
"{",
"builders",
"[",
"i",
"]",
"=",
"client",
"(",
")",
"prepare",
"index",
"(",
"\"",
"test",
"\"",
")",
"set",
"source",
"(",
"\"",
"field",
"\"",
",",
"\"",
"value",
"\"",
")",
";",
"}",
"index",
"random",
"(",
"true",
",",
"builders",
")",
";",
"ensure",
"green",
"(",
")",
";",
"/",
"/",
"double",
"flush",
"to",
"create",
"safe",
"commit",
"in",
"case",
"of",
"async",
"durability",
"assert",
"all",
"successful",
"(",
"client",
"(",
")",
"admin",
"(",
")",
"indices",
"(",
")",
"prepare",
"flush",
"(",
")",
"set",
"force",
"(",
"true",
")",
"get",
"(",
")",
")",
";",
"assert",
"all",
"successful",
"(",
"client",
"(",
")",
"admin",
"(",
")",
"indices",
"(",
")",
"prepare",
"flush",
"(",
")",
"set",
"force",
"(",
"true",
")",
"get",
"(",
")",
")",
";",
"/",
"/",
"we",
"have",
"to",
"flush",
"at",
"least",
"once",
"here",
"since",
"we",
"don",
"'",
"t",
"corrupt",
"the",
"translog",
"search",
"response",
"count",
"response",
"=",
"client",
"(",
")",
"prepare",
"search",
"(",
")",
"set",
"size",
"(",
"0",
")",
"get",
"(",
")",
";",
"assert",
"hit",
"count",
"(",
"count",
"response",
",",
"num",
"docs",
")",
";",
"shard",
"routing",
"shard",
"routing",
"=",
"corrupt",
"random",
"primary",
"file",
"(",
")",
";",
"/",
"*",
"*",
"we",
"corrupted",
"the",
"primary",
"shard",
"-",
"now",
"lets",
"make",
"sure",
"we",
"never",
"recover",
"from",
"it",
"successfully",
"*",
"/",
"settings",
"build",
"=",
"settings",
"builder",
"(",
")",
"put",
"(",
"index",
"metadata",
"setting",
"number",
"of",
"replicas",
",",
"\"",
"1",
"\"",
")",
"build",
"(",
")",
";",
"client",
"(",
")",
"admin",
"(",
")",
"indices",
"(",
")",
"prepare",
"update",
"settings",
"(",
"\"",
"test",
"\"",
")",
"set",
"settings",
"(",
"build",
")",
"get",
"(",
")",
";",
"client",
"(",
")",
"admin",
"(",
")",
"cluster",
"(",
")",
"prepare",
"reroute",
"(",
")",
"get",
"(",
")",
";",
"boolean",
"did",
"cluster",
"turn",
"red",
"=",
"wait",
"until",
"(",
"(",
")",
"-",
">",
"{",
"cluster",
"health",
"status",
"test",
"=",
"client",
"(",
")",
"admin",
"(",
")",
"cluster",
"(",
")",
"health",
"(",
"requests",
"cluster",
"health",
"request",
"(",
"\"",
"test",
"\"",
")",
")",
"action",
"get",
"(",
")",
"get",
"status",
"(",
")",
";",
"return",
"test",
"=",
"=",
"cluster",
"health",
"status",
"red",
";",
"}",
",",
"5",
",",
"time",
"unit",
"minutes",
")",
";",
"/",
"/",
"sometimes",
"on",
"slow",
"nodes",
"the",
"replication",
"/",
"recovery",
"is",
"just",
"dead",
"slow",
"final",
"cluster",
"health",
"response",
"response",
"=",
"client",
"(",
")",
"admin",
"(",
")",
"cluster",
"(",
")",
"health",
"(",
"requests",
"cluster",
"health",
"request",
"(",
"\"",
"test",
"\"",
")",
")",
"get",
"(",
")",
";",
"if",
"(",
"response",
"get",
"status",
"(",
")",
"!",
"=",
"cluster",
"health",
"status",
"red",
")",
"{",
"logger",
"info",
"(",
"\"",
"cluster",
"turned",
"red",
"in",
"busy",
"loop",
":",
"{",
"}",
"\"",
",",
"did",
"cluster",
"turn",
"red",
")",
";",
"logger",
"info",
"(",
"\"",
"cluster",
"state",
":",
"\\",
"n",
"{",
"}",
"\\",
"n",
"{",
"}",
"\"",
",",
"client",
"(",
")",
"admin",
"(",
")",
"cluster",
"(",
")",
"prepare",
"state",
"(",
")",
"get",
"(",
")",
"get",
"state",
"(",
")",
",",
"client",
"(",
")",
"admin",
"(",
")",
"cluster",
"(",
")",
"prepare",
"pending",
"cluster",
"tasks",
"(",
")",
"get",
"(",
")",
")",
";",
"}",
"assert",
"that",
"(",
"response",
"get",
"status",
"(",
")",
",",
"is",
"(",
"cluster",
"health",
"status",
"red",
")",
")",
";",
"cluster",
"state",
"state",
"=",
"client",
"(",
")",
"admin",
"(",
")",
"cluster",
"(",
")",
"prepare",
"state",
"(",
")",
"get",
"(",
")",
"get",
"state",
"(",
")",
";",
"group",
"shards",
"iterator",
"<",
"shard",
"iterator",
">",
"shard",
"iterators",
"=",
"state",
"get",
"routing",
"table",
"(",
")",
"active",
"primary",
"shards",
"grouped",
"(",
"new",
"string",
"[",
"]",
"{",
"\"",
"test",
"\"",
"}",
",",
"false",
")",
";",
"for",
"(",
"shard",
"iterator",
"iterator",
":",
"shard",
"iterators",
")",
"{",
"shard",
"routing",
"routing",
";",
"while",
"(",
"(",
"routing",
"=",
"iterator",
"next",
"or",
"null",
"(",
")",
")",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"routing",
"get",
"id",
"(",
")",
"=",
"=",
"shard",
"routing",
"get",
"id",
"(",
")",
")",
"{",
"assert",
"that",
"(",
"routing",
"state",
"(",
")",
",",
"equal",
"to",
"(",
"shard",
"routing",
"state",
"unassigned",
")",
")",
";",
"}",
"else",
"{",
"assert",
"that",
"(",
"routing",
"state",
"(",
")",
",",
"any",
"of",
"(",
"equal",
"to",
"(",
"shard",
"routing",
"state",
"relocating",
")",
",",
"equal",
"to",
"(",
"shard",
"routing",
"state",
"started",
")",
")",
")",
";",
"}",
"}",
"}",
"final",
"list",
"<",
"path",
">",
"files",
"=",
"list",
"shard",
"files",
"(",
"shard",
"routing",
")",
";",
"path",
"corrupted",
"file",
"=",
"null",
";",
"for",
"(",
"path",
"file",
":",
"files",
")",
"{",
"if",
"(",
"file",
"get",
"file",
"name",
"(",
")",
"to",
"string",
"(",
")",
"starts",
"with",
"(",
"\"",
"corrupted",
"\"",
")",
")",
"{",
"corrupted",
"file",
"=",
"file",
";",
"break",
";",
"}",
"}",
"assert",
"that",
"(",
"corrupted",
"file",
",",
"not",
"null",
"value",
"(",
")",
")",
";",
"}"
] |
[
"verify",
"equality",
"of",
"two",
"namespace",
"-",
"related",
"fields",
",",
"throwing",
"an",
"exception",
"if",
"they",
"are",
"unequal"
] |
[
"private",
"static",
"void",
"check",
"n",
"s",
"equality",
"(",
"object",
"our",
"i",
"d",
",",
"object",
"their",
"i",
"d",
",",
"string",
"id",
"help",
"text",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"!",
"our",
"i",
"d",
"equals",
"(",
"their",
"i",
"d",
")",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"id",
"help",
"text",
"+",
"\"",
"mismatch",
":",
"\"",
"+",
"\"",
"previously",
"connected",
"to",
"\"",
"+",
"id",
"help",
"text",
"+",
"\"",
"\"",
"+",
"our",
"i",
"d",
"+",
"\"",
"but",
"now",
"connected",
"to",
"\"",
"+",
"id",
"help",
"text",
"+",
"\"",
"\"",
"+",
"their",
"i",
"d",
")",
";",
"}",
"}"
] |
[
"remove",
"the",
"attribute",
"with",
"the",
"specified",
"name",
"from",
"this",
"attribute",
"manager"
] |
[
"public",
"void",
"remove",
"attribute",
"(",
"string",
"attribute",
"name",
")",
"{",
"defined",
"attributes",
"remove",
"(",
"attribute",
"name",
")",
";",
"}"
] |
[
"tests",
"that",
"the",
"fs",
"initialization",
"should",
"ignore",
"the",
"port",
"number",
"when",
"it",
"'",
"s",
"extracting",
"the",
"mount",
"table",
"name",
"from",
"uri"
] |
[
"public",
"void",
"test",
"mount",
"table",
"name",
"should",
"ignore",
"port",
"from",
"u",
"r",
"i",
"(",
")",
"throws",
"exception",
"{",
"final",
"path",
"hdfs",
"target",
"path",
"=",
"new",
"path",
"(",
"default",
"f",
"s",
"u",
"r",
"i",
"+",
"hdfs",
"user",
"folder",
")",
";",
"conf",
"=",
"new",
"configuration",
"(",
"get",
"conf",
"(",
")",
")",
";",
"add",
"mount",
"links",
"(",
"default",
"f",
"s",
"u",
"r",
"i",
"get",
"host",
"(",
")",
",",
"new",
"string",
"[",
"]",
"{",
"hdfs",
"user",
"folder",
",",
"local",
"folder",
",",
"constants",
"config",
"viewfs",
"link",
"fallback",
"}",
",",
"new",
"string",
"[",
"]",
"{",
"hdfs",
"target",
"path",
"to",
"uri",
"(",
")",
"to",
"string",
"(",
")",
",",
"local",
"target",
"dir",
"to",
"u",
"r",
"i",
"(",
")",
"to",
"string",
"(",
")",
",",
"hdfs",
"target",
"path",
"to",
"uri",
"(",
")",
"to",
"string",
"(",
")",
"}",
",",
"conf",
")",
";",
"conf",
"set",
"(",
"common",
"configuration",
"keys",
"fs",
"default",
"name",
"key",
",",
"default",
"f",
"s",
"u",
"r",
"i",
"to",
"string",
"(",
")",
")",
";",
"conf",
"set",
"(",
"string",
"format",
"(",
"fs",
"impl",
"pattern",
"key",
",",
"hdfs",
"scheme",
")",
",",
"view",
"file",
"system",
"overload",
"scheme",
"class",
"get",
"name",
"(",
")",
")",
";",
"conf",
"set",
"(",
"string",
"format",
"(",
"fs",
"constants",
"fs",
"viewfs",
"overload",
"scheme",
"target",
"fs",
"impl",
"pattern",
",",
"hdfs",
"scheme",
")",
",",
"distributed",
"file",
"system",
"class",
"get",
"name",
"(",
")",
")",
";",
"conf",
"set",
"boolean",
"(",
"config",
"viewfs",
"ignore",
"port",
"in",
"mount",
"table",
"name",
",",
"true",
")",
";",
"path",
"test",
"dir",
"on",
"root",
"=",
"new",
"path",
"(",
"\"",
"/",
"test",
"\"",
")",
";",
"uri",
"uri",
"without",
"port",
"=",
"new",
"uri",
"(",
"\"",
"hdfs",
":",
"/",
"/",
"\"",
"+",
"default",
"f",
"s",
"u",
"r",
"i",
"get",
"host",
"(",
")",
")",
";",
"/",
"/",
"initialize",
"with",
"out",
"port",
"try",
"(",
"file",
"system",
"fs",
"=",
"file",
"system",
"get",
"(",
"uri",
"without",
"port",
",",
"conf",
")",
")",
"{",
"fs",
"mkdirs",
"(",
"test",
"dir",
"on",
"root",
")",
";",
"fs",
"delete",
"(",
"test",
"dir",
"on",
"root",
",",
"true",
")",
";",
"}",
"/",
"/",
"initialize",
"with",
"port",
"try",
"(",
"file",
"system",
"fs",
"=",
"file",
"system",
"get",
"(",
"default",
"f",
"s",
"u",
"r",
"i",
",",
"conf",
")",
")",
"{",
"fs",
"mkdirs",
"(",
"test",
"dir",
"on",
"root",
")",
";",
"fs",
"delete",
"(",
"test",
"dir",
"on",
"root",
",",
"true",
")",
";",
"}",
"}"
] |
[
"sets",
"action",
"name"
] |
[
"public",
"void",
"set",
"action",
"name",
"(",
"string",
"action",
"name",
")",
"{",
"this",
"action",
"name",
"=",
"action",
"name",
";",
"}"
] |
[
"fires",
"the",
"given",
"debug",
"event"
] |
[
"public",
"static",
"void",
"fire",
"event",
"(",
"debug",
"event",
"event",
")",
"{",
"debug",
"plugin",
"manager",
"=",
"debug",
"plugin",
"get",
"default",
"(",
")",
";",
"if",
"(",
"manager",
"!",
"=",
"null",
")",
"{",
"manager",
"fire",
"debug",
"event",
"set",
"(",
"new",
"debug",
"event",
"[",
"]",
"{",
"event",
"}",
")",
";",
"}",
"}"
] |
[
"check",
"if",
"the",
"code",
"injection",
"does",
"not",
"return"
] |
[
"private",
"boolean",
"is",
"no",
"return",
"injection",
"(",
"function",
"f",
",",
"string",
"fixupname",
")",
"{",
"if",
"(",
"fixupname",
"=",
"=",
"null",
")",
"{",
"return",
"false",
";",
"}",
"/",
"/",
"if",
"the",
"callfixup",
"has",
"no",
"fallthru",
",",
"set",
"the",
"noreturn",
"property",
"too",
"program",
"program",
"=",
"f",
"get",
"program",
"(",
")",
";",
"inject",
"payload",
"call",
"fixup",
"=",
"program",
"get",
"compiler",
"spec",
"(",
")",
"get",
"pcode",
"inject",
"library",
"(",
")",
"get",
"payload",
"(",
"inject",
"payload",
"callfixup",
"type",
",",
"fixupname",
",",
"program",
",",
"null",
")",
";",
"if",
"(",
"call",
"fixup",
"=",
"=",
"null",
")",
"{",
"return",
"false",
";",
"}",
"return",
"!",
"call",
"fixup",
"is",
"fall",
"thru",
"(",
")",
";",
"}"
] |
[
"uses",
"a",
"hash",
"table",
"to",
"map",
"keys",
"to",
"value",
"collections",
"the",
"collections",
"returned",
"by",
"{",
"@",
"link",
"multimap",
"#",
"key",
"set",
"(",
")",
"}",
",",
"{",
"@",
"link",
"multimap",
"#",
"keys",
"(",
")",
"}",
",",
"and",
"{",
"@",
"link",
"multimap",
"#",
"as",
"map",
"(",
")",
"}",
"will",
"iterate",
"through",
"the",
"keys",
"in",
"the",
"order",
"that",
"they",
"were",
"first",
"added",
"to",
"the",
"multimap",
",",
"save",
"that",
"if",
"all",
"values",
"associated",
"with",
"a",
"key",
"are",
"removed",
"and",
"then",
"the",
"key",
"is",
"added",
"back",
"into",
"the",
"multimap",
",",
"that",
"key",
"will",
"come",
"last",
"in",
"the",
"key",
"iteration",
"order"
] |
[
"public",
"static",
"multimap",
"builder",
"with",
"keys",
"<",
"object",
">",
"linked",
"hash",
"keys",
"(",
")",
"{",
"return",
"linked",
"hash",
"keys",
"(",
"default",
"expected",
"keys",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"quadrilateral",
"type",
"'"
] |
[
"public",
"void",
"quadrilateral",
"type",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"quadrilateral",
"type",
"}"
] |
[
"add",
"format",
"change",
"listener",
"listeners",
"will",
"only",
"be",
"notified",
"if",
"auto",
"update",
"was",
"true",
"when",
"instantiated"
] |
[
"public",
"void",
"add",
"change",
"listener",
"(",
"change",
"listener",
"listener",
")",
"{",
"listeners",
"add",
"(",
"listener",
")",
";",
"}"
] |
[
"gets",
"the",
"canonicalized",
"resource",
"string",
"for",
"a",
"blob",
"or",
"queue",
"service",
"request",
"under",
"the",
"shared",
"key",
"lite",
"authentication",
"scheme"
] |
[
"private",
"static",
"string",
"get",
"canonicalized",
"resource",
"(",
"final",
"url",
"address",
",",
"final",
"string",
"account",
"name",
")",
"throws",
"unsupported",
"encoding",
"exception",
"{",
"/",
"/",
"resource",
"path",
"final",
"string",
"builder",
"resourcepath",
"=",
"new",
"string",
"builder",
"(",
"abfs",
"http",
"constants",
"forward",
"slash",
")",
";",
"resourcepath",
"append",
"(",
"account",
"name",
")",
";",
"/",
"/",
"note",
"that",
"absolute",
"path",
"starts",
"with",
"a",
"'",
"/",
"'",
"resourcepath",
"append",
"(",
"address",
"get",
"path",
"(",
")",
")",
";",
"final",
"string",
"builder",
"canonicalized",
"resource",
"=",
"new",
"string",
"builder",
"(",
"resourcepath",
"to",
"string",
"(",
")",
")",
";",
"/",
"/",
"query",
"parameters",
"if",
"(",
"address",
"get",
"query",
"(",
")",
"=",
"=",
"null",
"|",
"|",
"!",
"address",
"get",
"query",
"(",
")",
"contains",
"(",
"abfs",
"http",
"constants",
"equal",
")",
")",
"{",
"/",
"/",
"no",
"query",
"params",
"return",
"canonicalized",
"resource",
"to",
"string",
"(",
")",
";",
"}",
"final",
"map",
"<",
"string",
",",
"string",
"[",
"]",
">",
"query",
"variables",
"=",
"parse",
"query",
"string",
"(",
"address",
"get",
"query",
"(",
")",
")",
";",
"final",
"map",
"<",
"string",
",",
"string",
">",
"lowercased",
"key",
"name",
"value",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"for",
"(",
"final",
"entry",
"<",
"string",
",",
"string",
"[",
"]",
">",
"entry",
":",
"query",
"variables",
"entry",
"set",
"(",
")",
")",
"{",
"/",
"/",
"sort",
"the",
"value",
"and",
"organize",
"it",
"as",
"comma",
"separated",
"values",
"final",
"list",
"<",
"string",
">",
"sorted",
"values",
"=",
"arrays",
"as",
"list",
"(",
"entry",
"get",
"value",
"(",
")",
")",
";",
"collections",
"sort",
"(",
"sorted",
"values",
")",
";",
"final",
"string",
"builder",
"string",
"value",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"for",
"(",
"final",
"string",
"value",
":",
"sorted",
"values",
")",
"{",
"if",
"(",
"string",
"value",
"length",
"(",
")",
">",
"0",
")",
"{",
"string",
"value",
"append",
"(",
"abfs",
"http",
"constants",
"comma",
")",
";",
"}",
"string",
"value",
"append",
"(",
"value",
")",
";",
"}",
"/",
"/",
"key",
"turns",
"out",
"to",
"be",
"null",
"for",
"?",
"a",
"&",
"b",
"&",
"c",
"&",
"d",
"lowercased",
"key",
"name",
"value",
"put",
"(",
"(",
"entry",
"get",
"key",
"(",
")",
")",
"=",
"=",
"null",
"?",
"null",
":",
"entry",
"get",
"key",
"(",
")",
"to",
"lower",
"case",
"(",
"locale",
"root",
")",
",",
"string",
"value",
"to",
"string",
"(",
")",
")",
";",
"}",
"final",
"array",
"list",
"<",
"string",
">",
"sorted",
"keys",
"=",
"new",
"array",
"list",
"<",
"string",
">",
"(",
"lowercased",
"key",
"name",
"value",
"key",
"set",
"(",
")",
")",
";",
"collections",
"sort",
"(",
"sorted",
"keys",
")",
";",
"for",
"(",
"final",
"string",
"key",
":",
"sorted",
"keys",
")",
"{",
"final",
"string",
"builder",
"query",
"param",
"string",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"query",
"param",
"string",
"append",
"(",
"key",
")",
";",
"query",
"param",
"string",
"append",
"(",
"\"",
":",
"\"",
")",
";",
"query",
"param",
"string",
"append",
"(",
"lowercased",
"key",
"name",
"value",
"get",
"(",
"key",
")",
")",
";",
"append",
"canonicalized",
"element",
"(",
"canonicalized",
"resource",
",",
"query",
"param",
"string",
"to",
"string",
"(",
")",
")",
";",
"}",
"return",
"canonicalized",
"resource",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"opens",
"a",
"new",
"buffered",
"{",
"@",
"link",
"writer",
"}",
"for",
"writing",
"to",
"this",
"sink",
"the",
"returned",
"stream",
"is",
"not",
"required",
"to",
"be",
"a",
"{",
"@",
"link",
"buffered",
"writer",
"}",
"in",
"order",
"to",
"allow",
"implementations",
"to",
"simply",
"delegate",
"to",
"{",
"@",
"link",
"#",
"open",
"stream",
"(",
")",
"}",
"when",
"the",
"stream",
"returned",
"by",
"that",
"method",
"does",
"not",
"benefit",
"from",
"additional",
"buffering",
"this",
"method",
"returns",
"a",
"new",
",",
"independent",
"writer",
"each",
"time",
"it",
"is",
"called",
"the",
"caller",
"is",
"responsible",
"for",
"ensuring",
"that",
"the",
"returned",
"writer",
"is",
"closed"
] |
[
"public",
"writer",
"open",
"buffered",
"stream",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"writer",
"writer",
"=",
"open",
"stream",
"(",
")",
";",
"return",
"(",
"writer",
"instanceof",
"buffered",
"writer",
")",
"?",
"(",
"buffered",
"writer",
")",
"writer",
":",
"new",
"buffered",
"writer",
"(",
"writer",
")",
";",
"}"
] |
[
"returns",
"true",
"if",
"this",
"is",
"a",
"boxed",
"primitive",
"type",
"like",
"{",
"@",
"code",
"integer",
"}",
"returns",
"false",
"for",
"all",
"other",
"types",
"types",
"including",
"unboxed",
"primitives",
"and",
"{",
"@",
"code",
"java",
"lang",
"void",
"}"
] |
[
"public",
"boolean",
"is",
"boxed",
"primitive",
"(",
")",
"{",
"return",
"this",
"equals",
"(",
"boxed",
"boolean",
")",
"|",
"|",
"this",
"equals",
"(",
"boxed",
"byte",
")",
"|",
"|",
"this",
"equals",
"(",
"boxed",
"short",
")",
"|",
"|",
"this",
"equals",
"(",
"boxed",
"int",
")",
"|",
"|",
"this",
"equals",
"(",
"boxed",
"long",
")",
"|",
"|",
"this",
"equals",
"(",
"boxed",
"char",
")",
"|",
"|",
"this",
"equals",
"(",
"boxed",
"float",
")",
"|",
"|",
"this",
"equals",
"(",
"boxed",
"double",
")",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"public",
"void",
"make",
"accessible",
"(",
"accessible",
"object",
"ao",
")",
"{",
"ao",
"set",
"accessible",
"(",
"true",
")",
";",
"}"
] |
[
"overridden",
"for",
"performance",
"reasons",
"see",
"the",
"<",
"a",
"href",
"=",
"\"",
"#",
"override",
"\"",
">",
"implementation",
"note",
"for",
"more",
"information"
] |
[
"public",
"void",
"repaint",
"(",
"rectangle",
"r",
")",
"{",
"/",
"/",
"stub",
"}"
] |
[
"assert",
"the",
"response",
"status",
"code",
"is",
"{",
"@",
"code",
"http",
"status",
"request",
"header",
"fields",
"too",
"large",
"}",
"(",
"431",
")"
] |
[
"public",
"result",
"matcher",
"is",
"request",
"header",
"fields",
"too",
"large",
"(",
")",
"{",
"return",
"matcher",
"(",
"http",
"status",
"value",
"of",
"(",
"431",
")",
")",
";",
"}"
] |
[
"wakes",
"the",
"producer",
"thread",
"up",
"if",
"the",
"producer",
"thread",
"is",
"currently",
"blocked",
"in",
"the",
"{",
"@",
"link",
"#",
"produce",
"(",
"consumer",
"records",
")",
"}",
"method",
",",
"it",
"will",
"exit",
"the",
"method",
"throwing",
"a",
"{",
"@",
"link",
"wakeup",
"exception",
"}"
] |
[
"public",
"void",
"wakeup",
"producer",
"(",
")",
"{",
"synchronized",
"(",
"lock",
")",
"{",
"wakeup",
"producer",
"=",
"true",
";",
"lock",
"notify",
"all",
"(",
")",
";",
"}",
"}",
"/",
"/",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-",
"-"
] |
[
"get",
"the",
"current",
"interval",
"in",
"milliseconds",
"that",
"is",
"set",
"on",
"this",
"builder"
] |
[
"public",
"long",
"interval",
"(",
")",
"{",
"return",
"date",
"histogram",
"interval",
"interval",
"(",
")",
";",
"}"
] |
[
"return",
"the",
"bind",
"slot"
] |
[
"public",
"long",
"get",
"bind",
"slot",
"(",
")",
"{",
"return",
"bind",
"slot",
";",
"}"
] |
[
"assert",
"that",
"a",
"path",
"must",
"exist",
",",
"map",
"i",
"o",
"es",
"to",
"r",
"t",
"es",
"for",
"loops"
] |
[
"private",
"void",
"path",
"must",
"exist",
"(",
"path",
"p",
")",
"{",
"eval",
"(",
"(",
")",
"-",
">",
"assert",
"path",
"exists",
"(",
"\"",
"missing",
"path",
"\"",
",",
"p",
")",
")",
";",
"}"
] |
[
"gets",
"the",
"rackname",
"where",
"the",
"attempt",
"executed"
] |
[
"public",
"string",
"get",
"rack",
"name",
"(",
")",
"{",
"return",
"rack",
"name",
"=",
"=",
"null",
"?",
"null",
":",
"rack",
"name",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"count",
"of",
"markers",
"deleted"
] |
[
"int",
"get",
"markers",
"deleted",
"(",
")",
"{",
"return",
"markers",
"deleted",
";",
"}"
] |
[
"decrement",
"update",
"in",
"progress",
"count",
"indicating",
"that",
"an",
"update",
"operation",
"has",
"completed",
"and",
"check",
"the",
"update",
"refresh",
"reqd",
"flag",
"and",
"perform",
"refresh",
"if",
"needed"
] |
[
"synchronized",
"void",
"end",
"update",
"(",
")",
"{",
"if",
"(",
"-",
"-",
"update",
"in",
"progress",
"count",
"=",
"=",
"0",
"&",
"&",
"update",
"refresh",
"required",
")",
"{",
"refresh",
"(",
")",
";",
"}",
"}"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"return",
"the",
"number",
"of",
"variables",
"captured",
"by",
"the",
"path",
"element"
] |
[
"public",
"int",
"get",
"capture",
"count",
"(",
")",
"{",
"return",
"0",
";",
"}"
] |
[
"return",
"a",
"builder",
"for",
"a",
"{",
"@",
"code",
"content",
"disposition",
"}"
] |
[
"public",
"static",
"builder",
"builder",
"(",
"string",
"type",
")",
"{",
"return",
"new",
"builder",
"impl",
"(",
"type",
")",
";",
"}"
] |
[
"from",
"a",
"list",
"of",
"command",
"-",
"line",
"arguments",
",",
"remove",
"an",
"option"
] |
[
"public",
"static",
"boolean",
"pop",
"option",
"(",
"string",
"name",
",",
"list",
"<",
"string",
">",
"args",
")",
"{",
"for",
"(",
"iterator",
"<",
"string",
">",
"iter",
"=",
"args",
"iterator",
"(",
")",
";",
"iter",
"has",
"next",
"(",
")",
";",
")",
"{",
"string",
"cur",
"=",
"iter",
"next",
"(",
")",
";",
"if",
"(",
"cur",
"equals",
"(",
"\"",
"-",
"-",
"\"",
")",
")",
"{",
"/",
"/",
"stop",
"parsing",
"arguments",
"when",
"you",
"see",
"-",
"-",
"break",
";",
"}",
"else",
"if",
"(",
"cur",
"equals",
"(",
"name",
")",
")",
"{",
"iter",
"remove",
"(",
")",
";",
"return",
"true",
";",
"}",
"}",
"return",
"false",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.