docstring_tokens
list | code_tokens
list |
---|---|
[
"parses",
"information",
"to",
"determine",
"the",
"version",
"of",
"{",
"@",
"link",
"abstract",
"type",
"program",
"interface",
"}",
"to",
"create"
] |
[
"public",
"abstract",
"type",
"program",
"interface",
"parse",
"(",
"abstract",
"pdb",
"pdb",
",",
"task",
"monitor",
"monitor",
")",
"throws",
"i",
"o",
"exception",
",",
"pdb",
"exception",
",",
"cancelled",
"exception",
"{",
"abstract",
"type",
"program",
"interface",
"type",
"program",
"interface",
";",
"int",
"version",
"number",
"size",
"=",
"abstract",
"type",
"program",
"interface",
"get",
"version",
"number",
"size",
"(",
")",
";",
"int",
"stream",
"number",
"=",
"get",
"stream",
"number",
"(",
")",
";",
"pdb",
"byte",
"reader",
"reader",
"=",
"pdb",
"get",
"reader",
"for",
"stream",
"number",
"(",
"stream",
"number",
",",
"0",
",",
"version",
"number",
"size",
",",
"monitor",
")",
";",
"if",
"(",
"reader",
"get",
"limit",
"(",
")",
"<",
"version",
"number",
"size",
")",
"{",
"return",
"null",
";",
"}",
"int",
"version",
"number",
"=",
"abstract",
"type",
"program",
"interface",
"deserialize",
"version",
"number",
"(",
"reader",
")",
";",
"/",
"/",
"todo",
":",
"we",
"do",
"not",
"know",
"where",
"the",
"line",
"should",
"be",
"drawn",
"for",
"each",
"of",
"these",
"/",
"/",
"abstract",
"type",
"program",
"interface",
"instantiations",
"had",
"a",
"ti50",
"id",
"that",
"was",
"not",
"an",
"800",
"/",
"/",
"instead",
"of",
"a",
"500",
"also",
"believe",
"that",
"ti42",
"id",
"was",
"seen",
"to",
"have",
"500",
"rest",
"is",
"guess",
"/",
"/",
"until",
"we",
"can",
"validate",
"with",
"real",
"data",
"switch",
"(",
"version",
"number",
")",
"{",
"case",
"ti20",
"id",
":",
"case",
"ti40",
"id",
":",
"case",
"ti41",
"id",
":",
"type",
"program",
"interface",
"=",
"new",
"type",
"program",
"interface",
"2",
"0",
"0",
"(",
"pdb",
",",
"get",
"category",
"(",
")",
",",
"stream",
"number",
")",
";",
"break",
";",
"case",
"ti42",
"id",
":",
"case",
"ti50dep",
"id",
":",
"type",
"program",
"interface",
"=",
"new",
"type",
"program",
"interface",
"5",
"0",
"0",
"(",
"pdb",
",",
"get",
"category",
"(",
")",
",",
"stream",
"number",
")",
";",
"break",
";",
"case",
"ti50",
"id",
":",
"case",
"ti70",
"id",
":",
"case",
"ti80",
"id",
":",
"type",
"program",
"interface",
"=",
"new",
"type",
"program",
"interface",
"8",
"0",
"0",
"(",
"pdb",
",",
"get",
"category",
"(",
")",
",",
"stream",
"number",
")",
";",
"break",
";",
"default",
":",
"throw",
"new",
"pdb",
"exception",
"(",
"\"",
"unknown",
"tpi",
"version",
":",
"\"",
"+",
"version",
"number",
")",
";",
"}",
"return",
"type",
"program",
"interface",
";",
"}"
] |
[
"converts",
"this",
"report",
"to",
"a",
"map",
"the",
"returned",
"map",
"is",
"mutable",
",",
"and",
"changes",
"to",
"it",
"do",
"not",
"reflect",
"back",
"into",
"this",
"report"
] |
[
"public",
"map",
"<",
"long",
",",
"set",
"<",
"string",
">",
">",
"to",
"map",
"(",
")",
"{",
"return",
"deep",
"copy",
"(",
"id",
"2paths",
")",
";",
"}"
] |
[
"end",
"to",
"end",
"test",
"for",
"get",
"with",
"body",
"we",
"test",
"it",
"explicitly",
"as",
"it",
"is",
"not",
"supported",
"out",
"of",
"the",
"box",
"by",
"{",
"@",
"link",
"org",
"apache",
"http",
"client",
"http",
"client",
"}",
"exercises",
"the",
"test",
"http",
"server",
"ability",
"to",
"send",
"back",
"whatever",
"body",
"it",
"received"
] |
[
"public",
"void",
"test",
"get",
"with",
"body",
"(",
")",
"throws",
"exception",
"{",
"body",
"test",
"(",
"\"",
"get",
"\"",
")",
";",
"}"
] |
[
"initialize",
"the",
"rule",
"with",
"the",
"scheduler"
] |
[
"public",
"abstract",
"boolean",
"initialize",
"(",
"resource",
"scheduler",
"scheduler",
")",
"throws",
"i",
"o",
"exception",
";"
] |
[
"test",
"inline",
"additional",
"properties"
] |
[
"public",
"void",
"test",
"inline",
"additional",
"properties",
"(",
"map",
"<",
"string",
",",
"string",
">",
"param",
")",
"throws",
"api",
"exception",
"{",
"test",
"inline",
"additional",
"properties",
"with",
"http",
"info",
"(",
"param",
")",
";",
"}"
] |
[
"sets",
"the",
"relocation",
"offset",
"to",
"the",
"new",
"specified",
"value"
] |
[
"public",
"void",
"set",
"offset",
"(",
"long",
"offset",
")",
"{",
"this",
"r",
"offset",
"=",
"offset",
";",
"}"
] |
[
"returns",
"a",
"funnel",
"that",
"extracts",
"the",
"bytes",
"from",
"a",
"{",
"@",
"code",
"byte",
"}",
"array"
] |
[
"public",
"static",
"funnel",
"<",
"byte",
"[",
"]",
">",
"byte",
"array",
"funnel",
"(",
")",
"{",
"return",
"byte",
"array",
"funnel",
"instance",
";",
"}"
] |
[
"performs",
"auto",
"merge",
"of",
"functions",
"followed",
"by",
"merge",
"of",
"function",
"conflicts"
] |
[
"private",
"void",
"merge",
"functions",
"(",
"task",
"monitor",
"monitor",
")",
"throws",
"program",
"conflict",
"exception",
",",
"memory",
"access",
"exception",
",",
"cancelled",
"exception",
"{",
"display",
"initial",
"phase",
"message",
"(",
"functions",
"phase",
",",
"\"",
"merge",
"of",
"function",
"changes",
"\"",
")",
";",
"listing",
"merger",
"[",
"]",
"mergers",
"=",
"new",
"listing",
"merger",
"[",
"]",
"{",
"function",
"merger",
"}",
";",
"auto",
"merge",
"(",
"mergers",
",",
"monitor",
")",
";",
"merge",
"manager",
"show",
"progress",
"icon",
"(",
"false",
")",
";",
"merge",
"conflicts",
"(",
"mergers",
",",
"monitor",
")",
";",
"function",
"merger",
"merge",
"thunks",
"(",
"merge",
"panel",
",",
"conflict",
"option",
",",
"monitor",
")",
";",
"merge",
"manager",
"show",
"progress",
"icon",
"(",
"true",
")",
";",
"remove",
"bottom",
"component",
"(",
")",
";",
"merge",
"manager",
"set",
"completed",
"(",
"functions",
"phase",
")",
";",
"function",
"merger",
"dispose",
"(",
")",
";",
"}"
] |
[
"set",
"stderr",
"for",
"the",
"shell",
"script"
] |
[
"public",
"final",
"void",
"stderr",
"(",
"path",
"stderr",
"dir",
",",
"string",
"std",
"err",
"file",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"!",
"stderr",
"dir",
"is",
"absolute",
"(",
")",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"stdout",
"path",
"must",
"be",
"absolute",
"\"",
")",
";",
"}",
"redirect",
"std",
"err",
"=",
"true",
";",
"set",
"std",
"err",
"(",
"new",
"path",
"(",
"stderr",
"dir",
",",
"std",
"err",
"file",
")",
")",
";",
"}"
] |
[
"create",
"a",
"tree",
"using",
"the",
"values",
"'",
"natural",
"ordering"
] |
[
"public",
"static",
"<",
"k",
",",
"v",
"extends",
"comparable",
"<",
"v",
">",
">",
"tree",
"value",
"sorted",
"map",
"<",
"k",
",",
"v",
">",
"create",
"with",
"natural",
"order",
"(",
")",
"{",
"comparator",
"<",
"v",
">",
"natural",
"=",
"comparator",
"natural",
"order",
"(",
")",
";",
"return",
"new",
"tree",
"value",
"sorted",
"map",
"<",
">",
"(",
"natural",
")",
";",
"}"
] |
[
"checks",
"that",
"multiple",
"levels",
"of",
"nested",
"includes",
"where",
"a",
"node",
"is",
"both",
"directly",
"and",
"transitively",
"included",
"in",
"root",
"by",
"{",
"@",
"code",
"include",
"in",
"root",
"}",
"and",
"a",
"chain",
"of",
"{",
"@",
"code",
"include",
"in",
"parent",
"}",
"does",
"not",
"lead",
"to",
"duplicate",
"fields",
"on",
"the",
"root",
"document"
] |
[
"public",
"void",
"test",
"multiple",
"levels",
"include",
"root",
"1",
"(",
")",
"throws",
"exception",
"{",
"mapper",
"service",
"mapper",
"service",
"=",
"create",
"mapper",
"service",
"(",
"mapping",
"(",
"b",
"-",
">",
"{",
"}",
")",
")",
";",
"string",
"mapping",
"=",
"strings",
"to",
"string",
"(",
"x",
"content",
"factory",
"json",
"builder",
"(",
")",
"start",
"object",
"(",
")",
"start",
"object",
"(",
"mapper",
"service",
"single",
"mapping",
"name",
")",
"start",
"object",
"(",
"\"",
"properties",
"\"",
")",
"start",
"object",
"(",
"\"",
"nested",
"1",
"\"",
")",
"field",
"(",
"\"",
"type",
"\"",
",",
"\"",
"nested",
"\"",
")",
"field",
"(",
"\"",
"include",
"in",
"root",
"\"",
",",
"true",
")",
"field",
"(",
"\"",
"include",
"in",
"parent",
"\"",
",",
"true",
")",
"start",
"object",
"(",
"\"",
"properties",
"\"",
")",
"start",
"object",
"(",
"\"",
"nested",
"2",
"\"",
")",
"field",
"(",
"\"",
"type",
"\"",
",",
"\"",
"nested",
"\"",
")",
"field",
"(",
"\"",
"include",
"in",
"root",
"\"",
",",
"true",
")",
"field",
"(",
"\"",
"include",
"in",
"parent",
"\"",
",",
"true",
")",
"end",
"object",
"(",
")",
"end",
"object",
"(",
")",
"end",
"object",
"(",
")",
"end",
"object",
"(",
")",
"end",
"object",
"(",
")",
"end",
"object",
"(",
")",
")",
";",
"merge",
"reason",
"merge",
"reason",
"=",
"random",
"from",
"(",
"merge",
"reason",
"mapping",
"update",
",",
"merge",
"reason",
"index",
"template",
")",
";",
"mapper",
"service",
"merge",
"(",
"mapper",
"service",
"single",
"mapping",
"name",
",",
"new",
"compressed",
"x",
"content",
"(",
"mapping",
")",
",",
"merge",
"reason",
")",
";",
"document",
"mapper",
"doc",
"mapper",
"=",
"mapper",
"service",
"document",
"mapper",
"(",
")",
";",
"parsed",
"document",
"doc",
"=",
"doc",
"mapper",
"parse",
"(",
"new",
"source",
"to",
"parse",
"(",
"\"",
"test",
"\"",
",",
"\"",
"1",
"\"",
",",
"bytes",
"reference",
"bytes",
"(",
"x",
"content",
"factory",
"json",
"builder",
"(",
")",
"start",
"object",
"(",
")",
"start",
"array",
"(",
"\"",
"nested",
"1",
"\"",
")",
"start",
"object",
"(",
")",
"start",
"array",
"(",
"\"",
"nested",
"2",
"\"",
")",
"start",
"object",
"(",
")",
"field",
"(",
"\"",
"foo",
"\"",
",",
"\"",
"bar",
"\"",
")",
"end",
"object",
"(",
")",
"end",
"array",
"(",
")",
"end",
"object",
"(",
")",
"end",
"array",
"(",
")",
"end",
"object",
"(",
")",
")",
",",
"x",
"content",
"type",
"json",
")",
")",
";",
"final",
"collection",
"<",
"indexable",
"field",
">",
"fields",
"=",
"doc",
"root",
"doc",
"(",
")",
"get",
"fields",
"(",
")",
";",
"assert",
"that",
"(",
"fields",
"size",
"(",
")",
",",
"equal",
"to",
"(",
"new",
"hash",
"set",
"<",
">",
"(",
"fields",
")",
"size",
"(",
")",
")",
")",
";",
"}"
] |
[
"builds",
"a",
"list",
"of",
"{",
"@",
"link",
"path",
"}",
"that",
"represents",
"ancestors",
"from",
"a",
"string",
"like",
"\"",
"foobarzot",
"\""
] |
[
"private",
"list",
"<",
"path",
">",
"build",
"parent",
"path",
"(",
"string",
"path",
"list",
",",
"int",
"rest",
"size",
")",
"{",
"list",
"<",
"path",
">",
"r",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"string",
"tokenizer",
"tokens",
"=",
"new",
"string",
"tokenizer",
"(",
"path",
"list",
",",
"\"",
"/",
"\"",
")",
";",
"int",
"total",
"=",
"tokens",
"count",
"tokens",
"(",
")",
";",
"int",
"current",
"=",
"1",
";",
"while",
"(",
"tokens",
"has",
"more",
"tokens",
"(",
")",
")",
"{",
"string",
"token",
"=",
"tokens",
"next",
"token",
"(",
")",
";",
"r",
"add",
"(",
"new",
"path",
"(",
"create",
"back",
"ref",
"(",
"total",
"-",
"current",
"+",
"rest",
"size",
")",
",",
"token",
",",
"true",
",",
"0",
",",
"true",
",",
"0",
")",
")",
";",
"current",
"+",
"+",
";",
"}",
"return",
"r",
";",
"}"
] |
[
"calculates",
"the",
"crc",
"3",
"2",
"based",
"on",
"info",
"gathered",
"from",
"a",
"given",
"p",
"n",
"g",
"chunk"
] |
[
"private",
"byte",
"[",
"]",
"calculate",
"c",
"r",
"c",
"3",
"2",
"(",
"p",
"n",
"g",
"chunk",
"chunk",
")",
"{",
"crc32",
"checksum",
"=",
"new",
"crc32",
"(",
")",
";",
"checksum",
"update",
"(",
"byte",
"buffer",
"allocate",
"(",
"4",
"+",
"chunk",
"get",
"length",
"(",
")",
")",
"put",
"int",
"(",
"chunk",
"get",
"chunk",
"i",
"d",
"(",
")",
")",
"put",
"(",
"chunk",
"get",
"data",
"(",
")",
")",
"array",
"(",
")",
")",
";",
"long",
"result",
"=",
"checksum",
"get",
"value",
"(",
")",
";",
"return",
"byte",
"buffer",
"allocate",
"(",
"4",
")",
"put",
"int",
"(",
"(",
"int",
")",
"result",
")",
"array",
"(",
")",
";",
"}"
] |
[
"gets",
"registered",
"principal",
"resolvers"
] |
[
"collection",
"<",
"principal",
"resolver",
">",
"get",
"registered",
"principal",
"resolvers",
"(",
")",
";"
] |
[
"test",
"the",
"property",
"'",
"array",
"of",
"string",
"'"
] |
[
"public",
"void",
"array",
"of",
"string",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"array",
"of",
"string",
"}"
] |
[
"returns",
"the",
"expected",
"metric",
"id",
"for",
"a",
"given",
"metric",
"name",
"by",
"default",
"the",
"metric",
"name",
"without",
"any",
"modifications",
"is",
"returned"
] |
[
"string",
"get",
"expected",
"id",
"for",
"metric",
"name",
"(",
"final",
"string",
"metric",
"name",
")",
"{",
"return",
"metric",
"name",
";",
"}"
] |
[
"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",
"whether",
"the",
"parameter",
"is",
"declared",
"with",
"the",
"given",
"annotation",
"type"
] |
[
"public",
"<",
"a",
"extends",
"annotation",
">",
"boolean",
"has",
"parameter",
"annotation",
"(",
"class",
"<",
"a",
">",
"annotation",
"type",
")",
"{",
"return",
"(",
"get",
"parameter",
"annotation",
"(",
"annotation",
"type",
")",
"!",
"=",
"null",
")",
";",
"}"
] |
[
"all",
"implementations",
"must",
"call",
"this",
"method",
"before",
"writing",
"to",
"the",
"provided",
"stdout",
"stderr",
"or",
"to",
"any",
"of",
"the",
"output",
"file",
"locations",
"this",
"method",
"is",
"used",
"to",
"coordinate",
"-",
"implementations",
"must",
"throw",
"an",
"{",
"@",
"link",
"interrupted",
"exception",
"}",
"for",
"all",
"but",
"one",
"caller"
] |
[
"void",
"lock",
"output",
"files",
"(",
")",
"throws",
"interrupted",
"exception",
";"
] |
[
"the",
"i",
"pv",
"4",
"entries"
] |
[
"public",
"map",
"<",
"string",
",",
"inet",
"4",
"address",
">",
"inet",
"4",
"entries",
"(",
")",
"{",
"return",
"inet",
"4",
"entries",
";",
"}"
] |
[
"overridden",
"to",
"focus",
"the",
"text",
"field",
"if",
"request",
"focus",
"(",
")",
"is",
"called",
"on",
"this",
"panel"
] |
[
"public",
"void",
"request",
"focus",
"(",
")",
"{",
"filter",
"field",
"request",
"focus",
"(",
")",
";",
"}"
] |
[
"constructs",
"a",
"new",
"{",
"@",
"link",
"#",
"evaluator",
"}",
",",
"so",
"call",
"before",
"injecting",
"a",
"transformer",
"into",
"it",
"!"
] |
[
"public",
"void",
"initialize",
"(",
"boolean",
"keep",
"edges",
")",
"{",
"this",
"differencer",
"=",
"get",
"recording",
"differencer",
"(",
")",
";",
"this",
"evaluator",
"=",
"get",
"memoizing",
"evaluator",
"(",
"get",
"sky",
"function",
"map",
"(",
")",
",",
"differencer",
",",
"progress",
"receiver",
",",
"graph",
"inconsistency",
"receiver",
",",
"event",
"filter",
",",
"keep",
"edges",
")",
";",
"this",
"driver",
"=",
"get",
"build",
"driver",
"(",
"evaluator",
")",
";",
"}"
] |
[
"test",
"for",
"the",
"case",
"when",
"the",
"following",
"submit",
"application",
"and",
"administer",
"queue",
"a",
"c",
"ls",
"are",
"defined",
":",
"root",
":",
"(",
"none",
")",
"d",
":",
"(",
"all",
")",
"d1",
":",
"(",
"none",
")",
"expected",
"result",
":",
"access",
"to",
"d1",
"will",
"be",
"permitted",
"by",
"root",
"d",
",",
"so",
"the",
"user",
"will",
"be",
"able",
"to",
"access",
"queues",
"d",
"and",
"d1"
] |
[
"public",
"void",
"test",
"queue",
"acl",
"restricted",
"root",
"and",
"d",
"1",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"update",
"config",
"with",
"d",
"and",
"d",
"1",
"queues",
"(",
"none",
"acl",
",",
"all",
"acl",
",",
"none",
"acl",
")",
";",
"check",
"access",
"(",
"false",
",",
"true",
",",
"true",
")",
";",
"}"
] |
[
"tests",
"{",
"@",
"link",
"task",
"counter",
"}",
"'",
"s",
"{",
"@",
"link",
"task",
"counter",
"committed",
"heap",
"bytes",
"}",
"the",
"test",
"consists",
"of",
"running",
"a",
"low",
"-",
"memory",
"job",
"which",
"consumes",
"less",
"heap",
"memory",
"and",
"then",
"running",
"a",
"high",
"-",
"memory",
"job",
"which",
"consumes",
"more",
"heap",
"memory",
",",
"and",
"then",
"ensuring",
"that",
"committed",
"heap",
"bytes",
"of",
"low",
"-",
"memory",
"job",
"is",
"smaller",
"than",
"that",
"of",
"the",
"high",
"-",
"memory",
"job"
] |
[
"public",
"void",
"test",
"heap",
"usage",
"counter",
"(",
")",
"throws",
"exception",
"{",
"job",
"conf",
"conf",
"=",
"new",
"job",
"conf",
"(",
")",
";",
"/",
"/",
"create",
"a",
"local",
"filesystem",
"handle",
"file",
"system",
"file",
"system",
"=",
"file",
"system",
"get",
"local",
"(",
"conf",
")",
";",
"/",
"/",
"define",
"test",
"root",
"directories",
"path",
"root",
"dir",
"=",
"new",
"path",
"(",
"system",
"get",
"property",
"(",
"\"",
"test",
"build",
"data",
"\"",
",",
"\"",
"/",
"tmp",
"\"",
")",
")",
";",
"path",
"test",
"root",
"dir",
"=",
"new",
"path",
"(",
"root",
"dir",
",",
"\"",
"test",
"heap",
"usage",
"counter",
"\"",
")",
";",
"/",
"/",
"cleanup",
"the",
"test",
"root",
"directory",
"file",
"system",
"delete",
"(",
"test",
"root",
"dir",
",",
"true",
")",
";",
"/",
"/",
"set",
"the",
"current",
"working",
"directory",
"file",
"system",
"set",
"working",
"directory",
"(",
"test",
"root",
"dir",
")",
";",
"file",
"system",
"delete",
"on",
"exit",
"(",
"test",
"root",
"dir",
")",
";",
"/",
"/",
"create",
"a",
"mini",
"cluster",
"using",
"the",
"local",
"file",
"system",
"mini",
"m",
"r",
"cluster",
"mr",
"cluster",
"=",
"new",
"mini",
"m",
"r",
"cluster",
"(",
"1",
",",
"file",
"system",
"get",
"uri",
"(",
")",
"to",
"string",
"(",
")",
",",
"1",
")",
";",
"try",
"{",
"conf",
"=",
"mr",
"cluster",
"create",
"job",
"conf",
"(",
")",
";",
"job",
"client",
"job",
"client",
"=",
"new",
"job",
"client",
"(",
"conf",
")",
";",
"/",
"/",
"define",
"job",
"input",
"path",
"in",
"dir",
"=",
"new",
"path",
"(",
"test",
"root",
"dir",
",",
"\"",
"in",
"\"",
")",
";",
"/",
"/",
"create",
"input",
"data",
"create",
"words",
"file",
"(",
"in",
"dir",
",",
"conf",
")",
";",
"/",
"/",
"configure",
"and",
"run",
"a",
"low",
"memory",
"job",
"which",
"will",
"run",
"without",
"loading",
"the",
"/",
"/",
"jvm",
"'",
"s",
"heap",
"running",
"job",
"low",
"mem",
"job",
"=",
"run",
"heap",
"usage",
"test",
"job",
"(",
"conf",
",",
"test",
"root",
"dir",
",",
"\"",
"-",
"xms",
"3",
"2m",
"-",
"xmx",
"1",
"g",
"\"",
",",
"0",
",",
"0",
",",
"file",
"system",
",",
"job",
"client",
",",
"in",
"dir",
")",
";",
"job",
"i",
"d",
"low",
"mem",
"job",
"i",
"d",
"=",
"low",
"mem",
"job",
"get",
"i",
"d",
"(",
")",
";",
"long",
"low",
"mem",
"job",
"map",
"heap",
"usage",
"=",
"get",
"task",
"counter",
"usage",
"(",
"job",
"client",
",",
"low",
"mem",
"job",
"i",
"d",
",",
"1",
",",
"0",
",",
"task",
"type",
"map",
")",
";",
"system",
"out",
"println",
"(",
"\"",
"job",
"1",
"(",
"low",
"memory",
"job",
")",
"map",
"task",
"heap",
"usage",
":",
"\"",
"+",
"low",
"mem",
"job",
"map",
"heap",
"usage",
")",
";",
"long",
"low",
"mem",
"job",
"reduce",
"heap",
"usage",
"=",
"get",
"task",
"counter",
"usage",
"(",
"job",
"client",
",",
"low",
"mem",
"job",
"i",
"d",
",",
"1",
",",
"0",
",",
"task",
"type",
"reduce",
")",
";",
"system",
"out",
"println",
"(",
"\"",
"job",
"1",
"(",
"low",
"memory",
"job",
")",
"reduce",
"task",
"heap",
"usage",
":",
"\"",
"+",
"low",
"mem",
"job",
"reduce",
"heap",
"usage",
")",
";",
"/",
"/",
"configure",
"and",
"run",
"a",
"high",
"memory",
"job",
"which",
"will",
"load",
"the",
"jvm",
"'",
"s",
"heap",
"running",
"job",
"high",
"mem",
"job",
"=",
"run",
"heap",
"usage",
"test",
"job",
"(",
"conf",
",",
"test",
"root",
"dir",
",",
"\"",
"-",
"xms",
"3",
"2m",
"-",
"xmx",
"1",
"g",
"\"",
",",
"low",
"mem",
"job",
"map",
"heap",
"usage",
"+",
"256",
"*",
"1024",
"*",
"1024",
",",
"low",
"mem",
"job",
"reduce",
"heap",
"usage",
"+",
"256",
"*",
"1024",
"*",
"1024",
",",
"file",
"system",
",",
"job",
"client",
",",
"in",
"dir",
")",
";",
"job",
"i",
"d",
"high",
"mem",
"job",
"i",
"d",
"=",
"high",
"mem",
"job",
"get",
"i",
"d",
"(",
")",
";",
"long",
"high",
"mem",
"job",
"map",
"heap",
"usage",
"=",
"get",
"task",
"counter",
"usage",
"(",
"job",
"client",
",",
"high",
"mem",
"job",
"i",
"d",
",",
"1",
",",
"0",
",",
"task",
"type",
"map",
")",
";",
"system",
"out",
"println",
"(",
"\"",
"job",
"2",
"(",
"high",
"memory",
"job",
")",
"map",
"task",
"heap",
"usage",
":",
"\"",
"+",
"high",
"mem",
"job",
"map",
"heap",
"usage",
")",
";",
"long",
"high",
"mem",
"job",
"reduce",
"heap",
"usage",
"=",
"get",
"task",
"counter",
"usage",
"(",
"job",
"client",
",",
"high",
"mem",
"job",
"i",
"d",
",",
"1",
",",
"0",
",",
"task",
"type",
"reduce",
")",
";",
"system",
"out",
"println",
"(",
"\"",
"job",
"2",
"(",
"high",
"memory",
"job",
")",
"reduce",
"task",
"heap",
"usage",
":",
"\"",
"+",
"high",
"mem",
"job",
"reduce",
"heap",
"usage",
")",
";",
"assert",
"true",
"(",
"\"",
"incorrect",
"map",
"heap",
"usage",
"reported",
"by",
"the",
"map",
"task",
"\"",
",",
"low",
"mem",
"job",
"map",
"heap",
"usage",
"<",
"high",
"mem",
"job",
"map",
"heap",
"usage",
")",
";",
"assert",
"true",
"(",
"\"",
"incorrect",
"reduce",
"heap",
"usage",
"reported",
"by",
"the",
"reduce",
"task",
"\"",
",",
"low",
"mem",
"job",
"reduce",
"heap",
"usage",
"<",
"high",
"mem",
"job",
"reduce",
"heap",
"usage",
")",
";",
"}",
"finally",
"{",
"/",
"/",
"shutdown",
"the",
"mr",
"cluster",
"mr",
"cluster",
"shutdown",
"(",
")",
";",
"try",
"{",
"file",
"system",
"delete",
"(",
"test",
"root",
"dir",
",",
"true",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ioe",
")",
"{",
"}",
"}",
"}"
] |
[
"a",
"main",
"method",
"for",
"testing",
"the",
"splash",
"panel"
] |
[
"public",
"static",
"void",
"main",
"(",
"string",
"[",
"]",
"args",
")",
"{",
"j",
"frame",
"frame",
"=",
"new",
"j",
"frame",
"(",
")",
";",
"frame",
"set",
"title",
"(",
"\"",
"animation",
"\"",
")",
";",
"frame",
"set",
"size",
"(",
"800",
",",
"600",
")",
";",
"dimension",
"screen",
"size",
"=",
"toolkit",
"get",
"default",
"toolkit",
"(",
")",
"get",
"screen",
"size",
"(",
")",
";",
"dimension",
"frame",
"size",
"=",
"frame",
"get",
"size",
"(",
")",
";",
"frame",
"set",
"location",
"(",
"(",
"screen",
"size",
"width",
"-",
"frame",
"size",
"width",
")",
"/",
"2",
",",
"(",
"screen",
"size",
"height",
"-",
"frame",
"size",
"height",
")",
"/",
"2",
")",
";",
"sprite",
"sprite",
"=",
"new",
"clip",
"sprite",
"(",
"new",
"constant",
"color",
"(",
"color",
"white",
")",
",",
"new",
"constant",
"color",
"(",
"color",
"light",
"gray",
")",
",",
"new",
"circle",
"sprite",
"(",
"true",
",",
"new",
"linear",
"int",
"(",
"200",
",",
"600",
",",
"new",
"sine",
"timing",
"(",
"2345l",
",",
"0l",
")",
")",
",",
"new",
"linear",
"int",
"(",
"200",
",",
"400",
",",
"new",
"sine",
"timing",
"(",
"3210l",
",",
"0l",
")",
")",
",",
"new",
"constant",
"int",
"(",
"150",
")",
")",
",",
"new",
"color",
"sprite",
"(",
"new",
"constant",
"color",
"(",
"color",
"gray",
")",
",",
"new",
"font",
"sprite",
"(",
"new",
"constant",
"font",
"(",
"new",
"font",
"(",
"\"",
"sansserif",
"\"",
",",
"font",
"bold",
",",
"90",
")",
")",
",",
"new",
"text",
"sprite",
"(",
"new",
"constant",
"string",
"(",
"\"",
"pro",
"guard",
"\"",
")",
",",
"new",
"constant",
"int",
"(",
"200",
")",
",",
"new",
"constant",
"int",
"(",
"300",
")",
")",
")",
")",
")",
";",
"splash",
"panel",
"panel",
"=",
"new",
"splash",
"panel",
"(",
"sprite",
",",
"0",
"5",
")",
";",
"panel",
"set",
"background",
"(",
"color",
"white",
")",
";",
"frame",
"get",
"content",
"pane",
"(",
")",
"add",
"(",
"panel",
")",
";",
"frame",
"set",
"default",
"close",
"operation",
"(",
"j",
"frame",
"exit",
"on",
"close",
")",
";",
"frame",
"set",
"visible",
"(",
"true",
")",
";",
"panel",
"start",
"(",
")",
";",
"}"
] |
[
"test",
"to",
"check",
"the",
"bytes",
"read",
"from",
"buffer",
"statistic",
"value",
"from",
"abfs",
"input",
"stream"
] |
[
"public",
"void",
"test",
"bytes",
"read",
"from",
"buffer",
"statistic",
"(",
")",
"{",
"describe",
"(",
"\"",
"testing",
"bytes",
"read",
"from",
"buffer",
"statistics",
"value",
"in",
"abfs",
"input",
"stream",
"\"",
")",
";",
"abfs",
"input",
"stream",
"statistics",
"impl",
"abfs",
"input",
"stream",
"statistics",
"=",
"new",
"abfs",
"input",
"stream",
"statistics",
"impl",
"(",
")",
";",
"/",
"/",
"increment",
"the",
"bytes",
"read",
"from",
"buffer",
"value",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"operations",
";",
"i",
"+",
"+",
")",
"{",
"abfs",
"input",
"stream",
"statistics",
"bytes",
"read",
"from",
"buffer",
"(",
"1",
")",
";",
"}",
"/",
"*",
"*",
"since",
"we",
"incremented",
"the",
"bytes",
"read",
"from",
"buffer",
"operations",
"times",
",",
"this",
"*",
"should",
"be",
"the",
"expected",
"value",
"*",
"/",
"assert",
"equals",
"(",
"\"",
"mismatch",
"in",
"bytes",
"read",
"from",
"buffer",
"value",
"\"",
",",
"operations",
",",
"abfs",
"input",
"stream",
"statistics",
"get",
"bytes",
"read",
"from",
"buffer",
"(",
")",
")",
";",
"}"
] |
[
"returns",
"a",
"predicate",
"that",
"evaluates",
"to",
"true",
"for",
"rule",
"classes",
"that",
"are",
"allowed",
"labels",
"in",
"this",
"attribute",
"with",
"warning",
"if",
"this",
"is",
"not",
"a",
"label",
"or",
"label",
"-",
"list",
"attribute",
",",
"the",
"returned",
"predicate",
"always",
"evaluates",
"to",
"true"
] |
[
"public",
"predicate",
"<",
"rule",
"class",
">",
"get",
"allowed",
"rule",
"classes",
"warning",
"predicate",
"(",
")",
"{",
"return",
"allowed",
"rule",
"classes",
"for",
"labels",
"warning",
"as",
"predicate",
"of",
"rule",
"class",
"(",
")",
";",
"}"
] |
[
"create",
"a",
"new",
"{",
"@",
"link",
"config",
"def",
"}",
"instance",
"containing",
"the",
"configurations",
"defined",
"by",
"converter",
"config",
"this",
"can",
"be",
"called",
"by",
"subclasses"
] |
[
"public",
"static",
"config",
"def",
"new",
"config",
"def",
"(",
")",
"{",
"return",
"new",
"config",
"def",
"(",
")",
"define",
"(",
"type",
"config",
",",
"type",
"string",
",",
"config",
"def",
"no",
"default",
"value",
",",
"in",
"(",
"converter",
"type",
"key",
"get",
"name",
"(",
")",
",",
"converter",
"type",
"value",
"get",
"name",
"(",
")",
",",
"converter",
"type",
"header",
"get",
"name",
"(",
")",
")",
",",
"importance",
"low",
",",
"type",
"doc",
")",
";",
"}"
] |
[
"deletes",
"a",
"pet"
] |
[
"public",
"void",
"delete",
"pet",
"test",
"(",
")",
"throws",
"api",
"exception",
"{",
"/",
"/",
"long",
"pet",
"id",
"=",
"null",
";",
"/",
"/",
"string",
"api",
"key",
"=",
"null",
";",
"/",
"/",
"api",
"delete",
"pet",
"(",
"pet",
"id",
",",
"api",
"key",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
] |
[
"test",
"the",
"property",
"'",
"1",
"2",
"3number",
"'"
] |
[
"public",
"void",
"1",
"2",
"3number",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"1",
"2",
"3number",
"}"
] |
[
"called",
"when",
"the",
"offload",
"buffer",
"has",
"been",
"partially",
"emptied"
] |
[
"default",
"void",
"on",
"offload",
"buffer",
"emptying",
"(",
")",
"{",
"}"
] |
[
"returns",
"the",
"size",
"in",
"bytes",
"of",
"the",
"given",
"(",
"e",
"-",
")",
"ac",
"-",
"3",
"syncframe"
] |
[
"public",
"static",
"int",
"parse",
"ac",
"3",
"syncframe",
"size",
"(",
"byte",
"[",
"]",
"data",
")",
"{",
"if",
"(",
"data",
"length",
"<",
"6",
")",
"{",
"return",
"c",
"length",
"unset",
";",
"}",
"/",
"/",
"parse",
"the",
"bitstream",
"id",
"for",
"ac",
"-",
"3",
"and",
"e",
"-",
"ac",
"-",
"3",
"(",
"see",
"subsections",
"4",
"3",
",",
"e",
"1",
"2",
"and",
"e",
"1",
"3",
"1",
"6",
")",
"boolean",
"is",
"eac",
"3",
"=",
"(",
"(",
"data",
"[",
"5",
"]",
"&",
"0x",
"f",
"8",
")",
">",
">",
"3",
")",
">",
"10",
";",
"if",
"(",
"is",
"eac",
"3",
")",
"{",
"int",
"frmsiz",
"=",
"(",
"data",
"[",
"2",
"]",
"&",
"0x",
"0",
"7",
")",
"<",
"<",
"8",
";",
"/",
"/",
"most",
"significant",
"3",
"bits",
"frmsiz",
"|",
"=",
"data",
"[",
"3",
"]",
"&",
"0x",
"f",
"f",
";",
"/",
"/",
"least",
"significant",
"8",
"bits",
"return",
"(",
"frmsiz",
"+",
"1",
")",
"*",
"2",
";",
"/",
"/",
"see",
"frmsiz",
"in",
"subsection",
"e",
"1",
"3",
"1",
"3",
"}",
"else",
"{",
"int",
"fscod",
"=",
"(",
"data",
"[",
"4",
"]",
"&",
"0x",
"c",
"0",
")",
">",
">",
"6",
";",
"int",
"frmsizecod",
"=",
"data",
"[",
"4",
"]",
"&",
"0x",
"3",
"f",
";",
"return",
"get",
"ac",
"3",
"syncframe",
"size",
"(",
"fscod",
",",
"frmsizecod",
")",
";",
"}",
"}"
] |
[
"check",
"for",
"any",
"data",
"member",
"in",
"the",
"composite",
"with",
"the",
"specified",
"name",
"other",
"than",
"the",
"component",
"at",
"the",
"specified",
"index"
] |
[
"protected",
"boolean",
"name",
"exists",
"elsewhere",
"(",
"string",
"name",
",",
"int",
"row",
"index",
")",
"{",
"if",
"(",
"name",
"!",
"=",
"null",
")",
"{",
"int",
"num",
"components",
"=",
"get",
"num",
"components",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"row",
"index",
"&",
"&",
"i",
"<",
"num",
"components",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"name",
"equals",
"(",
"get",
"component",
"(",
"i",
")",
"get",
"field",
"name",
"(",
")",
")",
")",
"{",
"return",
"true",
";",
"}",
"}",
"for",
"(",
"int",
"i",
"=",
"row",
"index",
"+",
"1",
";",
"i",
"<",
"num",
"components",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"name",
"equals",
"(",
"get",
"component",
"(",
"i",
")",
"get",
"field",
"name",
"(",
")",
")",
")",
"{",
"return",
"true",
";",
"}",
"}",
"}",
"return",
"false",
";",
"}"
] |
[
"gets",
"the",
"setting",
"indicating",
"if",
"byte",
"differences",
"are",
"currently",
"being",
"ignored"
] |
[
"public",
"boolean",
"is",
"ignoring",
"byte",
"diffs",
"(",
")",
"{",
"return",
"ignore",
"byte",
"diffs",
";",
"}"
] |
[
"test",
"the",
"dfs",
"datanode",
"failed",
"volumes",
"tolerated",
"key",
"configuration",
"option",
",",
"ie",
"the",
"dn",
"tolerates",
"a",
"failed",
"-",
"to",
"-",
"use",
"scenario",
"during",
"its",
"start",
"-",
"up"
] |
[
"public",
"void",
"test",
"valid",
"volumes",
"at",
"startup",
"(",
")",
"throws",
"exception",
"{",
"assume",
"not",
"windows",
"(",
")",
";",
"/",
"/",
"make",
"sure",
"no",
"d",
"ns",
"are",
"running",
"cluster",
"shutdown",
"data",
"nodes",
"(",
")",
";",
"/",
"/",
"bring",
"up",
"a",
"datanode",
"with",
"two",
"default",
"data",
"dirs",
",",
"but",
"with",
"one",
"bad",
"one",
"conf",
"set",
"int",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"datanode",
"failed",
"volumes",
"tolerated",
"key",
",",
"1",
")",
";",
"/",
"/",
"we",
"use",
"subdirectories",
"0",
"and",
"1",
"in",
"order",
"to",
"have",
"only",
"a",
"single",
"/",
"/",
"data",
"dir",
"'",
"s",
"parent",
"inject",
"a",
"failure",
"file",
"tld",
"=",
"new",
"file",
"(",
"mini",
"d",
"f",
"s",
"cluster",
"get",
"base",
"directory",
"(",
")",
",",
"\"",
"bad",
"data",
"\"",
")",
";",
"file",
"data",
"dir",
"1",
"=",
"new",
"file",
"(",
"tld",
",",
"\"",
"data",
"1",
"\"",
")",
";",
"file",
"data",
"dir",
"1",
"actual",
"=",
"new",
"file",
"(",
"data",
"dir",
"1",
",",
"\"",
"1",
"\"",
")",
";",
"data",
"dir",
"1",
"actual",
"mkdirs",
"(",
")",
";",
"/",
"/",
"force",
"an",
"ioe",
"to",
"occur",
"on",
"one",
"of",
"the",
"dfs",
"data",
"dir",
"file",
"data",
"dir",
"2",
"=",
"new",
"file",
"(",
"tld",
",",
"\"",
"data",
"2",
"\"",
")",
";",
"prepare",
"dir",
"to",
"fail",
"(",
"data",
"dir",
"2",
")",
";",
"file",
"data",
"dir",
"2",
"actual",
"=",
"new",
"file",
"(",
"data",
"dir",
"2",
",",
"\"",
"2",
"\"",
")",
";",
"/",
"/",
"start",
"one",
"dn",
",",
"with",
"manually",
"managed",
"dn",
"dir",
"conf",
"set",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"datanode",
"data",
"dir",
"key",
",",
"data",
"dir",
"1",
"actual",
"get",
"path",
"(",
")",
"+",
"\"",
",",
"\"",
"+",
"data",
"dir",
"2",
"actual",
"get",
"path",
"(",
")",
")",
";",
"cluster",
"start",
"data",
"nodes",
"(",
"conf",
",",
"1",
",",
"false",
",",
"null",
",",
"null",
")",
";",
"cluster",
"wait",
"active",
"(",
")",
";",
"try",
"{",
"assert",
"true",
"(",
"\"",
"the",
"dn",
"should",
"have",
"started",
"up",
"fine",
"\"",
",",
"cluster",
"is",
"data",
"node",
"up",
"(",
")",
")",
";",
"data",
"node",
"dn",
"=",
"cluster",
"get",
"data",
"nodes",
"(",
")",
"get",
"(",
"0",
")",
";",
"string",
"si",
"=",
"data",
"node",
"test",
"utils",
"get",
"f",
"s",
"dataset",
"(",
"dn",
")",
"get",
"storage",
"info",
"(",
")",
";",
"assert",
"true",
"(",
"\"",
"the",
"dn",
"should",
"have",
"started",
"with",
"this",
"directory",
"\"",
",",
"si",
"contains",
"(",
"data",
"dir",
"1",
"actual",
"get",
"path",
"(",
")",
")",
")",
";",
"assert",
"false",
"(",
"\"",
"the",
"dn",
"shouldn",
"'",
"t",
"have",
"a",
"bad",
"directory",
"\"",
",",
"si",
"contains",
"(",
"data",
"dir",
"2",
"actual",
"get",
"path",
"(",
")",
")",
")",
";",
"}",
"finally",
"{",
"cluster",
"shutdown",
"data",
"nodes",
"(",
")",
";",
"file",
"util",
"chmod",
"(",
"data",
"dir",
"2",
"to",
"string",
"(",
")",
",",
"\"",
"755",
"\"",
")",
";",
"}",
"}"
] |
[
"writes",
"the",
"given",
"lines",
"of",
"text",
"to",
"this",
"sink",
"with",
"each",
"line",
"(",
"including",
"the",
"last",
")",
"terminated",
"with",
"the",
"operating",
"system",
"'",
"s",
"default",
"line",
"separator",
"this",
"method",
"is",
"equivalent",
"to",
"{",
"@",
"code",
"write",
"lines",
"(",
"lines",
",",
"system",
"get",
"property",
"(",
"\"",
"line",
"separator",
"\"",
")",
")",
"}"
] |
[
"public",
"void",
"write",
"lines",
"(",
"iterable",
"<",
"?",
"extends",
"char",
"sequence",
">",
"lines",
")",
"throws",
"i",
"o",
"exception",
"{",
"write",
"lines",
"(",
"lines",
",",
"system",
"get",
"property",
"(",
"\"",
"line",
"separator",
"\"",
")",
")",
";",
"}"
] |
[
"get",
"the",
"description",
"of",
"the",
"namenode",
"to",
"monitor"
] |
[
"public",
"string",
"get",
"namenode",
"desc",
"(",
")",
"{",
"if",
"(",
"namenode",
"id",
"!",
"=",
"null",
"&",
"&",
"!",
"namenode",
"id",
"is",
"empty",
"(",
")",
")",
"{",
"return",
"nameservice",
"id",
"+",
"\"",
"-",
"\"",
"+",
"namenode",
"id",
"+",
"\"",
":",
"\"",
"+",
"service",
"address",
";",
"}",
"else",
"{",
"return",
"nameservice",
"id",
"+",
"\"",
":",
"\"",
"+",
"service",
"address",
";",
"}",
"}"
] |
[
"set",
"the",
"specified",
"value",
"as",
"current",
"property",
"value"
] |
[
"void",
"set",
"property",
"value",
"(",
"property",
"value",
"pv",
")",
"throws",
"beans",
"exception",
";"
] |
[
"if",
"set",
",",
"will",
"enable",
"scrolling",
"of",
"the",
"search",
"request"
] |
[
"public",
"search",
"scroll",
"request",
"scroll",
"(",
"scroll",
"scroll",
")",
"{",
"this",
"scroll",
"=",
"scroll",
";",
"return",
"this",
";",
"}"
] |
[
"used",
"in",
"painless",
"scripting"
] |
[
"public",
"static",
"object",
"process",
"(",
"object",
"unit",
",",
"object",
"number",
"of",
"units",
",",
"object",
"timestamp",
",",
"zone",
"id",
"zone",
"id",
")",
"{",
"if",
"(",
"unit",
"=",
"=",
"null",
"|",
"|",
"number",
"of",
"units",
"=",
"=",
"null",
"|",
"|",
"timestamp",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"if",
"(",
"unit",
"instanceof",
"string",
"=",
"=",
"false",
")",
"{",
"throw",
"new",
"sql",
"illegal",
"argument",
"exception",
"(",
"\"",
"a",
"string",
"is",
"required",
";",
"received",
"[",
"{",
"}",
"]",
"\"",
",",
"unit",
")",
";",
"}",
"part",
"date",
"part",
"field",
"=",
"part",
"resolve",
"(",
"(",
"string",
")",
"unit",
")",
";",
"if",
"(",
"date",
"part",
"field",
"=",
"=",
"null",
")",
"{",
"list",
"<",
"string",
">",
"similar",
"=",
"part",
"find",
"similar",
"(",
"(",
"string",
")",
"unit",
")",
";",
"if",
"(",
"similar",
"is",
"empty",
"(",
")",
")",
"{",
"throw",
"new",
"sql",
"illegal",
"argument",
"exception",
"(",
"\"",
"a",
"value",
"of",
"{",
"}",
"or",
"their",
"aliases",
"is",
"required",
";",
"received",
"[",
"{",
"}",
"]",
"\"",
",",
"part",
"values",
"(",
")",
",",
"unit",
")",
";",
"}",
"else",
"{",
"throw",
"new",
"sql",
"illegal",
"argument",
"exception",
"(",
"\"",
"received",
"value",
"[",
"{",
"}",
"]",
"is",
"not",
"valid",
"date",
"part",
"to",
"add",
";",
"\"",
"+",
"\"",
"did",
"you",
"mean",
"{",
"}",
"?",
"\"",
",",
"unit",
",",
"similar",
")",
";",
"}",
"}",
"if",
"(",
"number",
"of",
"units",
"instanceof",
"number",
"=",
"=",
"false",
")",
"{",
"throw",
"new",
"sql",
"illegal",
"argument",
"exception",
"(",
"\"",
"a",
"number",
"is",
"required",
";",
"received",
"[",
"{",
"}",
"]",
"\"",
",",
"number",
"of",
"units",
")",
";",
"}",
"if",
"(",
"timestamp",
"instanceof",
"zoned",
"date",
"time",
"=",
"=",
"false",
")",
"{",
"throw",
"new",
"sql",
"illegal",
"argument",
"exception",
"(",
"\"",
"a",
"date",
"/",
"datetime",
"is",
"required",
";",
"received",
"[",
"{",
"}",
"]",
"\"",
",",
"timestamp",
")",
";",
"}",
"return",
"date",
"part",
"field",
"add",
"(",
"(",
"(",
"zoned",
"date",
"time",
")",
"timestamp",
")",
"with",
"zone",
"same",
"instant",
"(",
"zone",
"id",
")",
",",
"(",
"(",
"number",
")",
"number",
"of",
"units",
")",
"int",
"value",
"(",
")",
")",
";",
"}"
] |
[
"disable",
"erasure",
"coding",
"policy"
] |
[
"public",
"void",
"disable",
"erasure",
"coding",
"policy",
"(",
"string",
"ec",
"policy",
"name",
")",
"throws",
"i",
"o",
"exception",
"{",
"dfs",
"disable",
"erasure",
"coding",
"policy",
"(",
"ec",
"policy",
"name",
")",
";",
"}"
] |
[
"the",
"name",
"of",
"the",
"enumflag",
"as",
"a",
"reference",
"enumsflag",
"items",
"are",
"generated",
"as",
"id",
"resource",
"values",
"<",
"code",
">",
"optional",
"aapt",
"pb",
"reference",
"name",
"=",
"3",
";",
"<",
"code",
">"
] |
[
"private",
"void",
"clear",
"name",
"(",
")",
"{",
"name",
"=",
"null",
";",
"bit",
"field",
"0",
"=",
"(",
"bit",
"field",
"0",
"&",
"~",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"4",
")",
";",
"}"
] |
[
"register",
"a",
"listener",
"that",
"will",
"be",
"called",
"when",
"this",
"model",
"visibility",
"state",
"has",
"changed",
"the",
"listener",
"will",
"contribute",
"to",
"this",
"model",
"'",
"s",
"hash",
"code",
"state",
"per",
"the",
"{",
"@",
"link",
"com",
"airbnb",
"epoxy",
"epoxy",
"attribute",
"option",
"#",
"do",
"not",
"hash",
"}",
"rules"
] |
[
"public",
"generate",
"default",
"layout",
"method",
"on",
"visibility",
"state",
"changed",
"(",
"on",
"model",
"visibility",
"state",
"changed",
"listener",
"<",
"generate",
"default",
"layout",
"method",
",",
"object",
">",
"listener",
")",
"{",
"on",
"mutation",
"(",
")",
";",
"this",
"on",
"model",
"visibility",
"state",
"changed",
"listener",
"epoxy",
"generated",
"model",
"=",
"listener",
";",
"return",
"this",
";",
"}"
] |
[
"returns",
"a",
"predicate",
"that",
"evaluates",
"to",
"{",
"@",
"code",
"true",
"}",
"if",
"the",
"object",
"reference",
"being",
"tested",
"is",
"a",
"member",
"of",
"the",
"given",
"collection",
"it",
"does",
"not",
"defensively",
"copy",
"the",
"collection",
"passed",
"in",
",",
"so",
"future",
"changes",
"to",
"it",
"will",
"alter",
"the",
"behavior",
"of",
"the",
"predicate",
"this",
"method",
"can",
"technically",
"accept",
"any",
"{",
"@",
"code",
"collection",
"<",
"?",
">",
"}",
",",
"but",
"using",
"a",
"typed",
"collection",
"helps",
"prevent",
"bugs",
"this",
"approach",
"doesn",
"'",
"t",
"block",
"any",
"potential",
"users",
"since",
"it",
"is",
"always",
"possible",
"to",
"use",
"{",
"@",
"code",
"predicates",
"<",
"object",
">",
"in",
"(",
")",
"}"
] |
[
"public",
"static",
"<",
"t",
">",
"predicate",
"<",
"t",
">",
"in",
"(",
"collection",
"<",
"?",
"extends",
"t",
">",
"target",
")",
"{",
"return",
"new",
"in",
"predicate",
"<",
"t",
">",
"(",
"target",
")",
";",
"}"
] |
[
"returns",
"filesitems",
"with",
"the",
"specified",
"name",
"or",
"null",
"if",
"fileitem",
"not",
"found",
"within",
"this",
"folder"
] |
[
"public",
"repository",
"file",
"get",
"file",
"(",
"string",
"file",
"name",
")",
"{",
"synchronized",
"(",
"file",
"system",
")",
"{",
"repository",
"file",
"rf",
"=",
"file",
"map",
"get",
"(",
"file",
"name",
")",
";",
"if",
"(",
"rf",
"!",
"=",
"null",
")",
"{",
"return",
"rf",
";",
"}",
"if",
"(",
"file",
"system",
"file",
"exists",
"(",
"get",
"pathname",
"(",
")",
",",
"file",
"name",
")",
")",
"{",
"try",
"{",
"rf",
"=",
"new",
"repository",
"file",
"(",
"repository",
",",
"file",
"system",
",",
"this",
",",
"file",
"name",
")",
";",
"file",
"map",
"put",
"(",
"file",
"name",
",",
"rf",
")",
";",
"return",
"rf",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"log",
"error",
"(",
"\"",
"repository",
"'",
"\"",
"+",
"repository",
"get",
"name",
"(",
")",
"+",
"\"",
"'",
"file",
"error",
":",
"\"",
"+",
"e",
"get",
"message",
"(",
")",
"+",
"\"",
"\\",
"n",
"\"",
"+",
"make",
"pathname",
"(",
"get",
"pathname",
"(",
")",
",",
"file",
"name",
")",
")",
";",
"}",
"}",
"return",
"null",
";",
"}",
"}"
] |
[
"returns",
"the",
"hashed",
"index",
"for",
"the",
"given",
"key"
] |
[
"private",
"int",
"hash",
"index",
"(",
"int",
"key",
")",
"{",
"/",
"/",
"the",
"array",
"lengths",
"are",
"always",
"a",
"power",
"of",
"two",
",",
"so",
"we",
"can",
"use",
"a",
"bitmask",
"to",
"stay",
"inside",
"the",
"array",
"bounds",
"return",
"hash",
"code",
"(",
"key",
")",
"&",
"mask",
";",
"}"
] |
[
"enabledisable",
"contrast",
"mode"
] |
[
"public",
"void",
"set",
"contrast",
"mode",
"(",
"final",
"boolean",
"is",
"contrast",
"mode",
")",
"{",
"this",
"is",
"contrast",
"mode",
"=",
"is",
"contrast",
"mode",
";",
"}"
] |
[
"returns",
"the",
"duration",
"of",
"the",
"specified",
"chunk"
] |
[
"public",
"long",
"get",
"chunk",
"duration",
"us",
"(",
"int",
"chunk",
"index",
")",
"{",
"return",
"(",
"chunk",
"index",
"=",
"=",
"chunk",
"count",
"-",
"1",
")",
"?",
"last",
"chunk",
"duration",
"us",
":",
"chunk",
"start",
"times",
"us",
"[",
"chunk",
"index",
"+",
"1",
"]",
"-",
"chunk",
"start",
"times",
"us",
"[",
"chunk",
"index",
"]",
";",
"}"
] |
[
"look",
"up",
"an",
"external",
"rest",
"api"
] |
[
"public",
"string",
"lookup",
"external",
"rest",
"a",
"p",
"i",
"(",
"string",
"user",
",",
"string",
"service",
"class",
",",
"string",
"instance",
",",
"string",
"api",
")",
"throws",
"i",
"o",
"exception",
"{",
"string",
"qualified",
"=",
"qualify",
"user",
"(",
"user",
")",
";",
"string",
"path",
"=",
"service",
"path",
"(",
"qualified",
",",
"service",
"class",
",",
"instance",
")",
";",
"string",
"rest",
"a",
"p",
"i",
"=",
"resolve",
"external",
"rest",
"a",
"p",
"i",
"(",
"api",
",",
"path",
")",
";",
"if",
"(",
"rest",
"a",
"p",
"i",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"path",
"not",
"found",
"exception",
"(",
"path",
"+",
"\"",
"api",
"\"",
"+",
"api",
")",
";",
"}",
"return",
"rest",
"a",
"p",
"i",
";",
"}"
] |
[
"set",
"the",
"given",
"plain",
"text",
"and",
"html",
"text",
"as",
"alternatives",
",",
"offering",
"both",
"options",
"to",
"the",
"email",
"client",
"requires",
"multipart",
"mode",
"<",
"b",
">",
"note",
":",
"<",
"b",
">",
"invoke",
"{",
"@",
"link",
"#",
"add",
"inline",
"}",
"after",
"{",
"@",
"code",
"set",
"text",
"}",
";",
"else",
",",
"mail",
"readers",
"might",
"not",
"be",
"able",
"to",
"resolve",
"inline",
"references",
"correctly"
] |
[
"public",
"void",
"set",
"text",
"(",
"string",
"plain",
"text",
",",
"string",
"html",
"text",
")",
"throws",
"messaging",
"exception",
"{",
"assert",
"not",
"null",
"(",
"plain",
"text",
",",
"\"",
"plain",
"text",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"assert",
"not",
"null",
"(",
"html",
"text",
",",
"\"",
"html",
"text",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"mime",
"multipart",
"message",
"body",
"=",
"new",
"mime",
"multipart",
"(",
"multipart",
"subtype",
"alternative",
")",
";",
"get",
"main",
"part",
"(",
")",
"set",
"content",
"(",
"message",
"body",
",",
"content",
"type",
"alternative",
")",
";",
"/",
"/",
"create",
"the",
"plain",
"text",
"part",
"of",
"the",
"message",
"mime",
"body",
"part",
"plain",
"text",
"part",
"=",
"new",
"mime",
"body",
"part",
"(",
")",
";",
"set",
"plain",
"text",
"to",
"mime",
"part",
"(",
"plain",
"text",
"part",
",",
"plain",
"text",
")",
";",
"message",
"body",
"add",
"body",
"part",
"(",
"plain",
"text",
"part",
")",
";",
"/",
"/",
"create",
"the",
"html",
"text",
"part",
"of",
"the",
"message",
"mime",
"body",
"part",
"html",
"text",
"part",
"=",
"new",
"mime",
"body",
"part",
"(",
")",
";",
"set",
"html",
"text",
"to",
"mime",
"part",
"(",
"html",
"text",
"part",
",",
"html",
"text",
")",
";",
"message",
"body",
"add",
"body",
"part",
"(",
"html",
"text",
"part",
")",
";",
"}"
] |
[
"return",
"the",
"parcelable",
"in",
"cache"
] |
[
"public",
"static",
"<",
"t",
">",
"t",
"get",
"parcelable",
"(",
"@",
"non",
"null",
"final",
"string",
"key",
",",
"@",
"non",
"null",
"final",
"parcelable",
"creator",
"<",
"t",
">",
"creator",
")",
"{",
"return",
"get",
"parcelable",
"(",
"key",
",",
"creator",
",",
"get",
"default",
"cache",
"double",
"utils",
"(",
")",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"class",
"name",
"'"
] |
[
"public",
"void",
"class",
"name",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"class",
"name",
"}"
] |
[
"whether",
"the",
"node",
"has",
"been",
"logically",
"removed"
] |
[
"static",
"boolean",
"is",
"node",
"removed",
"(",
"long",
"node",
",",
"allocator",
"space",
"allocator",
")",
"{",
"if",
"(",
"node",
"=",
"=",
"nil",
"node",
")",
"{",
"return",
"false",
";",
"}",
"chunk",
"chunk",
"=",
"space",
"allocator",
"get",
"chunk",
"by",
"id",
"(",
"space",
"utils",
"get",
"chunk",
"id",
"by",
"address",
"(",
"node",
")",
")",
";",
"int",
"offset",
"in",
"chunk",
"=",
"space",
"utils",
"get",
"chunk",
"offset",
"by",
"address",
"(",
"node",
")",
";",
"memory",
"segment",
"segment",
"=",
"chunk",
"get",
"memory",
"segment",
"(",
"offset",
"in",
"chunk",
")",
";",
"int",
"offset",
"in",
"byte",
"buffer",
"=",
"chunk",
"get",
"offset",
"in",
"segment",
"(",
"offset",
"in",
"chunk",
")",
";",
"return",
"get",
"node",
"status",
"(",
"segment",
",",
"offset",
"in",
"byte",
"buffer",
")",
"=",
"=",
"node",
"status",
"remove",
";",
"}"
] |
[
"asynchronous",
"version",
"of",
"{",
"@",
"link",
"abstract",
"dao",
"#",
"insert",
"(",
"object",
")",
"}"
] |
[
"public",
"async",
"operation",
"insert",
"(",
"object",
"entity",
",",
"int",
"flags",
")",
"{",
"return",
"enqueue",
"entity",
"operation",
"(",
"operation",
"type",
"insert",
",",
"entity",
",",
"flags",
")",
";",
"}"
] |
[
"returns",
"the",
"next",
"captured",
"outbound",
"message",
"event"
] |
[
"string",
"next",
"inbound",
"event",
"(",
")",
";"
] |
[
"paint",
"the",
"element"
] |
[
"private",
"void",
"paint",
"(",
"paint",
"event",
"e",
")",
"{",
"/",
"*",
"*",
"draw",
"the",
"top",
"two",
"lines",
"of",
"the",
"tab",
",",
"same",
"for",
"selected",
",",
"hover",
"and",
"*",
"default",
"*",
"/",
"rectangle",
"bounds",
"=",
"get",
"bounds",
"(",
")",
";",
"e",
"gc",
"set",
"foreground",
"(",
"widget",
"normal",
"shadow",
")",
";",
"e",
"gc",
"draw",
"line",
"(",
"0",
",",
"0",
",",
"bounds",
"width",
"-",
"1",
",",
"0",
")",
";",
"e",
"gc",
"set",
"foreground",
"(",
"list",
"background",
")",
";",
"e",
"gc",
"draw",
"line",
"(",
"0",
",",
"1",
",",
"bounds",
"width",
"-",
"1",
",",
"1",
")",
";",
"/",
"*",
"draw",
"the",
"fill",
"in",
"the",
"tab",
"*",
"/",
"if",
"(",
"selected",
")",
"{",
"e",
"gc",
"set",
"background",
"(",
"list",
"background",
")",
";",
"e",
"gc",
"fill",
"rectangle",
"(",
"0",
",",
"2",
",",
"bounds",
"width",
",",
"bounds",
"height",
"-",
"1",
")",
";",
"}",
"else",
"if",
"(",
"hover",
"&",
"&",
"tab",
"is",
"indented",
"(",
")",
")",
"{",
"e",
"gc",
"set",
"background",
"(",
"indented",
"hover",
"background",
")",
";",
"e",
"gc",
"fill",
"rectangle",
"(",
"0",
",",
"2",
",",
"bounds",
"width",
"-",
"1",
",",
"bounds",
"height",
"-",
"1",
")",
";",
"}",
"else",
"if",
"(",
"hover",
")",
"{",
"e",
"gc",
"set",
"foreground",
"(",
"hover",
"gradient",
"start",
")",
";",
"e",
"gc",
"set",
"background",
"(",
"hover",
"gradient",
"end",
")",
";",
"e",
"gc",
"fill",
"gradient",
"rectangle",
"(",
"0",
",",
"2",
",",
"bounds",
"width",
"-",
"1",
",",
"bounds",
"height",
"-",
"1",
",",
"true",
")",
";",
"}",
"else",
"if",
"(",
"tab",
"is",
"indented",
"(",
")",
")",
"{",
"e",
"gc",
"set",
"background",
"(",
"indented",
"default",
"background",
")",
";",
"e",
"gc",
"fill",
"rectangle",
"(",
"0",
",",
"2",
",",
"bounds",
"width",
"-",
"1",
",",
"bounds",
"height",
"-",
"1",
")",
";",
"}",
"else",
"{",
"e",
"gc",
"set",
"background",
"(",
"element",
"background",
")",
";",
"e",
"gc",
"fill",
"rectangle",
"(",
"0",
",",
"2",
",",
"bounds",
"width",
"-",
"1",
",",
"bounds",
"height",
"-",
"1",
")",
";",
"/",
"/",
"e",
"gc",
"set",
"background",
"(",
"default",
"gradient",
"end",
")",
";",
"/",
"/",
"e",
"gc",
"fill",
"gradient",
"rectangle",
"(",
"0",
",",
"2",
",",
"bounds",
"width",
"-",
"1",
",",
"bounds",
"height",
"-",
"1",
",",
"true",
")",
";",
"}",
"if",
"(",
"!",
"selected",
")",
"{",
"e",
"gc",
"set",
"foreground",
"(",
"widget",
"normal",
"shadow",
")",
";",
"e",
"gc",
"draw",
"line",
"(",
"bounds",
"width",
"-",
"1",
",",
"1",
",",
"bounds",
"width",
"-",
"1",
",",
"bounds",
"height",
"+",
"1",
")",
";",
"}",
"/",
"*",
"*",
"add",
"indent",
"left",
"pixels",
"to",
"the",
"left",
"as",
"a",
"margin",
"*",
"/",
"int",
"text",
"indent",
"=",
"indent",
"left",
";",
"font",
"metrics",
"fm",
"=",
"e",
"gc",
"get",
"font",
"metrics",
"(",
")",
";",
"int",
"height",
"=",
"fm",
"get",
"height",
"(",
")",
";",
"int",
"text",
"middle",
"=",
"(",
"bounds",
"height",
"-",
"height",
")",
"/",
"2",
";",
"if",
"(",
"tab",
"get",
"image",
"(",
")",
"!",
"=",
"null",
")",
"{",
"/",
"*",
"draw",
"the",
"icon",
"for",
"the",
"selected",
"tab",
"*",
"/",
"if",
"(",
"tab",
"is",
"indented",
"(",
")",
")",
"{",
"text",
"indent",
"=",
"text",
"indent",
"+",
"indent",
"left",
";",
"}",
"else",
"{",
"text",
"indent",
"=",
"text",
"indent",
"-",
"3",
";",
"}",
"image",
"image",
"=",
"d",
"beaver",
"icons",
"get",
"image",
"(",
"tab",
"get",
"image",
"(",
")",
")",
";",
"if",
"(",
"selected",
"|",
"|",
"hover",
")",
"{",
"e",
"gc",
"draw",
"image",
"(",
"image",
",",
"text",
"indent",
",",
"text",
"middle",
"-",
"1",
")",
";",
"}",
"else",
"{",
"e",
"gc",
"draw",
"image",
"(",
"get",
"grayed",
"image",
"(",
"image",
")",
",",
"text",
"indent",
",",
"text",
"middle",
"-",
"1",
")",
";",
"}",
"text",
"indent",
"=",
"text",
"indent",
"+",
"image",
"get",
"bounds",
"(",
")",
"width",
"+",
"4",
";",
"}",
"else",
"if",
"(",
"tab",
"is",
"indented",
"(",
")",
")",
"{",
"text",
"indent",
"=",
"text",
"indent",
"+",
"indent",
"left",
";",
"}",
"/",
"*",
"draw",
"the",
"text",
"*",
"/",
"e",
"gc",
"set",
"foreground",
"(",
"widget",
"foreground",
")",
";",
"if",
"(",
"selected",
")",
"{",
"/",
"*",
"selected",
"tab",
"is",
"bold",
"font",
"*",
"/",
"e",
"gc",
"set",
"font",
"(",
"j",
"face",
"resources",
"get",
"font",
"registry",
"(",
")",
"get",
"bold",
"(",
"j",
"face",
"resources",
"default",
"font",
")",
")",
";",
"}",
"e",
"gc",
"draw",
"text",
"(",
"tab",
"get",
"text",
"(",
")",
",",
"text",
"indent",
",",
"text",
"middle",
",",
"true",
")",
";",
"if",
"(",
"(",
"(",
"tabbed",
"folder",
"list",
")",
"get",
"parent",
"(",
")",
")",
"focus",
"&",
"&",
"selected",
")",
"{",
"/",
"*",
"draw",
"a",
"line",
"if",
"the",
"tab",
"has",
"focus",
"*",
"/",
"point",
"point",
"=",
"e",
"gc",
"text",
"extent",
"(",
"tab",
"get",
"text",
"(",
")",
")",
";",
"e",
"gc",
"draw",
"line",
"(",
"text",
"indent",
",",
"bounds",
"height",
"-",
"4",
",",
"text",
"indent",
"+",
"point",
"x",
",",
"bounds",
"height",
"-",
"4",
")",
";",
"}",
"/",
"*",
"draw",
"the",
"bottom",
"line",
"on",
"the",
"tab",
"for",
"selected",
"and",
"default",
"*",
"/",
"if",
"(",
"!",
"hover",
")",
"{",
"e",
"gc",
"set",
"foreground",
"(",
"list",
"background",
")",
";",
"e",
"gc",
"draw",
"line",
"(",
"0",
",",
"bounds",
"height",
"-",
"1",
",",
"bounds",
"width",
"-",
"2",
",",
"bounds",
"height",
"-",
"1",
")",
";",
"}",
"}"
] |
[
"move",
"the",
"cursor",
"to",
"the",
"front",
"of",
"this",
"row",
"set",
",",
"just",
"before",
"the",
"first",
"row"
] |
[
"void",
"before",
"first",
"(",
")",
"throws",
"invalid",
"result",
"set",
"access",
"exception",
";"
] |
[
"indicate",
"that",
"the",
"test",
"run",
"has",
"started",
"this",
"should",
"be",
"called",
"after",
"all",
"filtering",
"has",
"been",
"completed"
] |
[
"public",
"void",
"test",
"run",
"started",
"(",
"description",
"top",
"level",
"description",
")",
"{",
"mark",
"children",
"as",
"pending",
"(",
"top",
"level",
"description",
")",
";",
"}"
] |
[
"associates",
"the",
"given",
"value",
"with",
"every",
"index",
"from",
"start",
"to",
"end",
"(",
"inclusive",
")",
"any",
"previous",
"associates",
"are",
"overwritten"
] |
[
"public",
"void",
"paint",
"range",
"(",
"address",
"start",
"addr",
",",
"address",
"end",
"addr",
",",
"field",
"value",
")",
"{",
"lock",
"acquire",
"(",
")",
";",
"try",
"{",
"last",
"start",
"=",
"start",
"addr",
";",
"last",
"end",
"=",
"end",
"addr",
";",
"last",
"value",
"=",
"value",
";",
"last",
"range",
"=",
"null",
";",
"if",
"(",
"start",
"addr",
"compare",
"to",
"(",
"end",
"addr",
")",
">",
"0",
")",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
")",
";",
"+",
"+",
"mod",
"count",
";",
"for",
"(",
"key",
"range",
"range",
":",
"addr",
"map",
"get",
"key",
"ranges",
"(",
"start",
"addr",
",",
"end",
"addr",
",",
"true",
")",
")",
"{",
"paint",
"range",
"(",
"range",
"min",
"key",
",",
"range",
"max",
"key",
",",
"value",
")",
";",
"}",
"}",
"finally",
"{",
"lock",
"release",
"(",
")",
";",
"}",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"public",
"void",
"visit",
"move",
"insn",
"(",
"normal",
"ssa",
"insn",
"insn",
")",
"{",
"add",
"to",
"uses",
"(",
"insn",
")",
";",
"}"
] |
[
"renames",
"an",
"existing",
"map",
"directory"
] |
[
"public",
"static",
"void",
"rename",
"(",
"file",
"system",
"fs",
",",
"string",
"old",
"name",
",",
"string",
"new",
"name",
")",
"throws",
"i",
"o",
"exception",
"{",
"path",
"old",
"dir",
"=",
"new",
"path",
"(",
"old",
"name",
")",
";",
"path",
"new",
"dir",
"=",
"new",
"path",
"(",
"new",
"name",
")",
";",
"if",
"(",
"!",
"fs",
"rename",
"(",
"old",
"dir",
",",
"new",
"dir",
")",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"could",
"not",
"rename",
"\"",
"+",
"old",
"dir",
"+",
"\"",
"to",
"\"",
"+",
"new",
"dir",
")",
";",
"}",
"}"
] |
[
"default",
":",
"-",
"1"
] |
[
"public",
"builder",
"set",
"queue",
"size",
"per",
"handler",
"(",
"int",
"queue",
"size",
"per",
"handler",
")",
"{",
"this",
"queue",
"size",
"per",
"handler",
"=",
"queue",
"size",
"per",
"handler",
";",
"return",
"this",
";",
"}"
] |
[
"get",
"the",
"sum",
"of",
"each",
"subcluster",
"statistics"
] |
[
"private",
"long",
"[",
"]",
"get",
"aggregate",
"stats",
"(",
")",
"throws",
"exception",
"{",
"long",
"[",
"]",
"individual",
"data",
"=",
"new",
"long",
"[",
"10",
"]",
";",
"for",
"(",
"string",
"nameservice",
":",
"cluster",
"get",
"nameservices",
"(",
")",
")",
"{",
"namenode",
"context",
"n",
"=",
"cluster",
"get",
"namenode",
"(",
"nameservice",
",",
"null",
")",
";",
"d",
"f",
"s",
"client",
"client",
"=",
"n",
"get",
"client",
"(",
")",
";",
"client",
"protocol",
"client",
"protocol",
"=",
"client",
"get",
"namenode",
"(",
")",
";",
"long",
"[",
"]",
"data",
"=",
"client",
"protocol",
"get",
"stats",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"data",
"length",
";",
"i",
"+",
"+",
")",
"{",
"individual",
"data",
"[",
"i",
"]",
"+",
"=",
"data",
"[",
"i",
"]",
";",
"}",
"}",
"return",
"individual",
"data",
";",
"}"
] |
[
"returns",
"a",
"new",
"path",
"fragment",
"that",
"is",
"a",
"sub",
"fragment",
"of",
"this",
"one",
"the",
"sub",
"fragment",
"begins",
"at",
"the",
"specified",
"<",
"code",
">",
"begin",
"index",
"<",
"code",
">",
"segment",
"and",
"ends",
"at",
"the",
"segment",
"at",
"index",
"<",
"code",
">",
"end",
"index",
"-",
"1",
"<",
"code",
">",
"thus",
"the",
"number",
"of",
"segments",
"in",
"the",
"new",
"path",
"fragment",
"is",
"<",
"code",
">",
"end",
"index",
"-",
"begin",
"index",
"<",
"code",
">",
"this",
"operation",
"is",
"o",
"(",
"n",
")",
"on",
"the",
"length",
"of",
"the",
"string"
] |
[
"public",
"path",
"fragment",
"sub",
"fragment",
"(",
"int",
"begin",
"index",
",",
"int",
"end",
"index",
")",
"{",
"if",
"(",
"begin",
"index",
"<",
"0",
"|",
"|",
"begin",
"index",
">",
"end",
"index",
")",
"{",
"throw",
"new",
"index",
"out",
"of",
"bounds",
"exception",
"(",
"string",
"format",
"(",
"\"",
"path",
":",
"%",
"s",
",",
"begin",
"index",
":",
"%",
"d",
"end",
"index",
":",
"%",
"d",
"\"",
",",
"to",
"string",
"(",
")",
",",
"begin",
"index",
",",
"end",
"index",
")",
")",
";",
"}",
"return",
"sub",
"fragment",
"impl",
"(",
"begin",
"index",
",",
"end",
"index",
")",
";",
"}"
] |
[
"test",
"what",
"happens",
"when",
"an",
"impl",
"struct",
"contains",
"a",
"field",
"who",
"'",
"s",
"db",
"datatype",
"has",
"the",
"same",
"datatype",
"name",
"as",
"the",
"impl",
"struct",
"the",
"embedded",
"db",
"struct",
"needs",
"to",
"be",
"empty",
"and",
"default",
"sized",
"(",
"1",
"byte",
")",
",",
"and",
"the",
"outer",
"impl",
"struct",
"needs",
"to",
"be",
"bigger",
"currently",
"the",
"dtm",
"resolve",
"(",
")",
"will",
"ignore",
"the",
"conflict",
"handlers",
"attempt",
"to",
"replace",
"since",
"it",
"will",
"result",
"in",
"cyclic",
"dependency",
"issue",
"it",
"will",
"instead",
"rename",
"the",
"new",
"structure",
"as",
"a",
"conflict",
"with",
"its",
"field",
"refering",
"to",
"the",
"original",
"structure",
"this",
"situation",
"happens",
"in",
"dwarf",
"when",
"there",
"is",
"a",
"base",
"class",
"and",
"a",
"derived",
"class",
"that",
"have",
"the",
"same",
"name",
"they",
"are",
"in",
"different",
"namespaces",
",",
"but",
"during",
"compilation",
"gcc",
"was",
"told",
"to",
"-",
"feliminate",
"-",
"unused",
"-",
"debug",
"-",
"symbols",
"which",
"results",
"in",
"the",
"die",
"records",
"for",
"the",
"structs",
"being",
"placed",
"in",
"the",
"root",
"namespace",
"see",
"gdtsd",
"-",
"351"
] |
[
"public",
"void",
"test",
"d",
"t",
"m",
"incorrect",
"overwrite",
"(",
")",
"{",
"data",
"type",
"x",
"=",
"data",
"mgr",
"add",
"data",
"type",
"(",
"new",
"structure",
"data",
"type",
"(",
"root",
"c",
"p",
",",
"\"",
"x",
"\"",
",",
"1",
")",
",",
"null",
")",
";",
"structure",
"data",
"type",
"x",
"2",
"=",
"new",
"structure",
"data",
"type",
"(",
"root",
"c",
"p",
",",
"\"",
"x",
"\"",
",",
"4",
")",
";",
"x",
"2",
"replace",
"at",
"offset",
"(",
"0",
",",
"x",
",",
"1",
",",
"\"",
"f",
"1",
"\"",
",",
"null",
")",
";",
"structure",
"x",
"3",
"=",
"(",
"structure",
")",
"data",
"mgr",
"resolve",
"(",
"x",
"2",
",",
"data",
"type",
"conflict",
"handler",
"replace",
"handler",
")",
";",
"assert",
"equals",
"(",
"\"",
"x",
"conflict",
"\"",
",",
"x",
"3",
"get",
"name",
"(",
")",
")",
";",
"data",
"type",
"component",
"dtc",
"=",
"x",
"3",
"get",
"component",
"(",
"0",
")",
";",
"data",
"type",
"dtc",
"d",
"t",
"=",
"dtc",
"get",
"data",
"type",
"(",
")",
";",
"assert",
"equals",
"(",
"\"",
"f",
"1",
"\"",
",",
"dtc",
"get",
"field",
"name",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"x",
"\"",
",",
"dtc",
"d",
"t",
"get",
"name",
"(",
")",
")",
";",
"/",
"/",
"undefined",
"field",
"is",
"current",
"behavior",
"}"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"highlights",
"any",
"y",
"-",
"value",
"at",
"the",
"given",
"x",
"-",
"value",
"in",
"the",
"given",
"data",
"set",
"provide",
"-",
"1",
"as",
"the",
"data",
"set",
"index",
"to",
"undo",
"all",
"highlighting"
] |
[
"public",
"void",
"highlight",
"value",
"(",
"float",
"x",
",",
"float",
"y",
",",
"int",
"data",
"set",
"index",
",",
"boolean",
"call",
"listener",
")",
"{",
"highlight",
"value",
"(",
"x",
",",
"y",
",",
"data",
"set",
"index",
",",
"-",
"1",
",",
"call",
"listener",
")",
";",
"}"
] |
[
"post",
"fakeoutercomposite",
"test",
"serialization",
"of",
"object",
"with",
"outer",
"number",
"type"
] |
[
"default",
"response",
"entity",
"<",
"outer",
"composite",
">",
"fake",
"outer",
"composite",
"serialize",
"(",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"input",
"composite",
"as",
"post",
"body",
"\"",
")",
"@",
"valid",
"@",
"request",
"body",
"(",
"required",
"=",
"false",
")",
"outer",
"composite",
"body",
")",
"{",
"return",
"get",
"delegate",
"(",
")",
"fake",
"outer",
"composite",
"serialize",
"(",
"body",
")",
";",
"}"
] |
[
"pulls",
"out",
"the",
"value",
"of",
"the",
"equate",
"given",
"the",
"formatted",
"equate",
"name",
"the",
"value",
"stored",
"in",
"the",
"equate",
"info",
"is",
"a",
"decimal"
] |
[
"public",
"static",
"long",
"get",
"equate",
"value",
"from",
"formatted",
"name",
"(",
"string",
"formatted",
"equate",
"name",
")",
"{",
"if",
"(",
"formatted",
"equate",
"name",
"starts",
"with",
"(",
"datatype",
"tag",
")",
")",
"{",
"return",
"long",
"parse",
"long",
"(",
"formatted",
"equate",
"name",
"split",
"(",
"format",
"delimiter",
")",
"[",
"2",
"]",
")",
";",
"}",
"return",
"-",
"1",
";",
"}"
] |
[
"auxiliary",
"method",
"to",
"read",
"the",
"length",
"of",
"an",
"upcoming",
"data",
"chunk",
"from",
"an",
"input",
"stream"
] |
[
"static",
"int",
"read",
"length",
"(",
"input",
"stream",
"input",
"stream",
")",
"throws",
"i",
"o",
"exception",
"{",
"byte",
"[",
"]",
"buf",
"=",
"new",
"byte",
"[",
"4",
"]",
";",
"int",
"bytes",
"read",
"=",
"0",
";",
"while",
"(",
"bytes",
"read",
"<",
"4",
")",
"{",
"final",
"int",
"read",
"=",
"input",
"stream",
"read",
"(",
"buf",
",",
"bytes",
"read",
",",
"4",
"-",
"bytes",
"read",
")",
";",
"if",
"(",
"read",
"<",
"0",
")",
"{",
"throw",
"new",
"e",
"o",
"f",
"exception",
"(",
"\"",
"read",
"an",
"incomplete",
"length",
"\"",
")",
";",
"}",
"bytes",
"read",
"+",
"=",
"read",
";",
"}",
"bytes",
"read",
"=",
"buf",
"[",
"0",
"]",
"&",
"0xff",
";",
"bytes",
"read",
"|",
"=",
"(",
"buf",
"[",
"1",
"]",
"&",
"0xff",
")",
"<",
"<",
"8",
";",
"bytes",
"read",
"|",
"=",
"(",
"buf",
"[",
"2",
"]",
"&",
"0xff",
")",
"<",
"<",
"16",
";",
"bytes",
"read",
"|",
"=",
"(",
"buf",
"[",
"3",
"]",
"&",
"0xff",
")",
"<",
"<",
"24",
";",
"return",
"bytes",
"read",
";",
"}"
] |
[
"try",
"to",
"come",
"up",
"with",
"a",
"good",
"temp",
"directory",
"for",
"different",
"filesystems"
] |
[
"public",
"static",
"path",
"temp",
"dir",
"for",
"staging",
"(",
"file",
"system",
"fs",
",",
"configuration",
"conf",
")",
"{",
"string",
"fallback",
"path",
"=",
"fs",
"get",
"scheme",
"(",
")",
"equals",
"(",
"\"",
"file",
"\"",
")",
"?",
"system",
"get",
"property",
"(",
"java",
"io",
"tmpdir",
")",
":",
"filesystem",
"temp",
"path",
";",
"return",
"fs",
"make",
"qualified",
"(",
"new",
"path",
"(",
"conf",
"get",
"trimmed",
"(",
"fs",
"s3a",
"committer",
"staging",
"tmp",
"path",
",",
"fallback",
"path",
")",
")",
")",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"public",
"boolean",
"equals",
"(",
"object",
"obj",
")",
"{",
"if",
"(",
"this",
"=",
"=",
"obj",
")",
"return",
"true",
";",
"else",
"if",
"(",
"obj",
"!",
"=",
"null",
"&",
"&",
"obj",
"instanceof",
"arithmetic",
"progression",
")",
"{",
"final",
"arithmetic",
"progression",
"that",
"=",
"(",
"arithmetic",
"progression",
")",
"obj",
";",
"if",
"(",
"this",
"symbol",
"!",
"=",
"that",
"symbol",
")",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"this",
"symbol",
"!",
"=",
"that",
"symbol",
",",
"this",
"=",
"\"",
"+",
"this",
"+",
"\"",
",",
"that",
"=",
"\"",
"+",
"that",
")",
";",
"return",
"this",
"value",
"=",
"=",
"that",
"value",
"&",
"&",
"this",
"delta",
"=",
"=",
"that",
"delta",
"&",
"&",
"this",
"limit",
"=",
"=",
"that",
"limit",
";",
"}",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"obj",
"=",
"=",
"null",
"?",
"\"",
"obj",
"=",
"=",
"null",
"\"",
":",
"\"",
"obj",
"get",
"class",
"(",
")",
"=",
"\"",
"+",
"obj",
"get",
"class",
"(",
")",
")",
";",
"}"
] |
[
"set",
"the",
"maximum",
"split",
"size"
] |
[
"public",
"static",
"void",
"set",
"max",
"input",
"split",
"size",
"(",
"job",
"job",
",",
"long",
"size",
")",
"{",
"job",
"get",
"configuration",
"(",
")",
"set",
"long",
"(",
"split",
"maxsize",
",",
"size",
")",
";",
"}"
] |
[
"returns",
"a",
"key",
"for",
"building",
"a",
"file",
"value",
"for",
"the",
"given",
"root",
"-",
"relative",
"path"
] |
[
"public",
"static",
"key",
"key",
"(",
"rooted",
"path",
"rooted",
"path",
")",
"{",
"return",
"key",
"create",
"(",
"rooted",
"path",
")",
";",
"}"
] |
[
"a",
"utility",
"function",
"which",
"generates",
"the",
"\"",
"deps",
"\"",
"clause",
"for",
"a",
"build",
"file",
"rule",
"from",
"a",
"list",
"of",
"targets"
] |
[
"protected",
"static",
"string",
"deps",
"(",
"string",
"dep",
"targets",
")",
"{",
"string",
"builder",
"buf",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"buf",
"append",
"(",
"\"",
"deps",
"=",
"[",
"\"",
")",
";",
"string",
"sep",
"=",
"\"",
"'",
"\"",
";",
"for",
"(",
"string",
"dep",
":",
"dep",
"targets",
")",
"{",
"buf",
"append",
"(",
"sep",
")",
";",
"buf",
"append",
"(",
"dep",
")",
";",
"buf",
"append",
"(",
"\"",
"'",
"\"",
")",
";",
"sep",
"=",
"\"",
",",
"'",
"\"",
";",
"}",
"buf",
"append",
"(",
"\"",
"]",
"\"",
")",
";",
"return",
"buf",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"required",
":",
"the",
"port",
"on",
"which",
"the",
"proxy",
"should",
"listen",
"for",
"incoming",
"connections",
"<",
"code",
">",
"istio",
"networking",
"v",
"1alpha",
"3",
"port",
"port",
"=",
"1",
";",
"<",
"code",
">"
] |
[
"public",
"com",
"alibaba",
"nacos",
"istio",
"model",
"port",
"get",
"port",
"(",
")",
"{",
"return",
"port",
"=",
"=",
"null",
"?",
"com",
"alibaba",
"nacos",
"istio",
"model",
"port",
"get",
"default",
"instance",
"(",
")",
":",
"port",
";",
"}"
] |
[
"find",
"the",
"fields",
"constant",
"that",
"matches",
"field",
"id",
",",
"or",
"null",
"if",
"its",
"not",
"found"
] |
[
"public",
"static",
"fields",
"find",
"by",
"thrift",
"id",
"(",
"int",
"field",
"id",
")",
"{",
"switch",
"(",
"field",
"id",
")",
"{",
"case",
"1",
":",
"/",
"/",
"error",
"return",
"error",
";",
"case",
"2",
":",
"/",
"/",
"error",
"time",
"secs",
"return",
"error",
"time",
"secs",
";",
"default",
":",
"return",
"null",
";",
"}",
"}"
] |
[
"wraps",
"a",
"gl",
"interface",
"in",
"another",
"gl",
"interface"
] |
[
"gl",
"wrap",
"(",
"gl",
"gl",
")",
";"
] |
[
"ports",
"{",
"@",
"link",
"android",
"view",
"view",
"compat",
"#",
"set",
"accessibility",
"heading",
"}",
"into",
"components",
"world",
"however",
",",
"since",
"the",
"aforementioned",
"view",
"compat",
"'",
"s",
"method",
"is",
"available",
"only",
"on",
"api",
"19",
"and",
"above",
",",
"calling",
"this",
"method",
"on",
"lower",
"a",
"p",
"is",
"will",
"have",
"no",
"effect",
"on",
"the",
"legit",
"versions",
",",
"on",
"the",
"other",
"hand",
",",
"calling",
"this",
"method",
"will",
"lead",
"to",
"the",
"component",
"being",
"treated",
"as",
"a",
"heading",
"the",
"accessibility",
"heading",
"property",
"allows",
"accessibility",
"services",
"to",
"help",
"users",
"navigate",
"directly",
"from",
"one",
"heading",
"to",
"the",
"next",
"see",
"<",
"a",
"href",
"=",
"\"",
"https",
":",
"developer",
"android",
"comreferenceandroidsupportv",
"4viewaccessibility",
"accessibility",
"node",
"info",
"compat",
"#",
"setheading",
"\"",
">",
"https",
":",
"developer",
"android",
"comreferenceandroid",
"supportv",
"4viewaccessibility",
"accessibility",
"node",
"info",
"compat",
"#",
"setheading",
"for",
"more",
"information",
"default",
":",
"false"
] |
[
"public",
"t",
"accessibility",
"heading",
"(",
"boolean",
"is",
"heading",
")",
"{",
"m",
"component",
"get",
"or",
"create",
"common",
"props",
"(",
")",
"accessibility",
"heading",
"(",
"is",
"heading",
")",
";",
"return",
"get",
"this",
"(",
")",
";",
"}"
] |
[
"starts",
"a",
"new",
"infinite",
"stream",
"of",
"dns",
"server",
"addresses",
"this",
"method",
"is",
"invoked",
"by",
"{",
"@",
"link",
"dns",
"name",
"resolver",
"}",
"on",
"every",
"uncached",
"{",
"@",
"link",
"dns",
"name",
"resolver",
"#",
"resolve",
"(",
"string",
")",
"}",
"or",
"{",
"@",
"link",
"dns",
"name",
"resolver",
"#",
"resolve",
"all",
"(",
"string",
")",
"}"
] |
[
"public",
"abstract",
"dns",
"server",
"address",
"stream",
"stream",
"(",
")",
";"
] |
[
"set",
"the",
"{",
"@",
"link",
"conversion",
"service",
"}",
"to",
"use",
"to",
"convert",
"the",
"original",
"message",
"payload",
"or",
"headers"
] |
[
"public",
"void",
"set",
"conversion",
"service",
"(",
"conversion",
"service",
"conversion",
"service",
")",
"{",
"this",
"conversion",
"service",
"=",
"conversion",
"service",
";",
"}"
] |
[
"compare",
"two",
"flash",
"maps",
"and",
"prefer",
"the",
"one",
"that",
"specifies",
"a",
"target",
"url",
"path",
"or",
"has",
"more",
"target",
"url",
"parameters",
"before",
"comparing",
"flash",
"map",
"instances",
"ensure",
"that",
"they",
"match",
"a",
"given",
"request"
] |
[
"public",
"int",
"compare",
"to",
"(",
"flash",
"map",
"other",
")",
"{",
"int",
"this",
"url",
"path",
"=",
"(",
"this",
"target",
"request",
"path",
"!",
"=",
"null",
"?",
"1",
":",
"0",
")",
";",
"int",
"other",
"url",
"path",
"=",
"(",
"other",
"target",
"request",
"path",
"!",
"=",
"null",
"?",
"1",
":",
"0",
")",
";",
"if",
"(",
"this",
"url",
"path",
"!",
"=",
"other",
"url",
"path",
")",
"{",
"return",
"other",
"url",
"path",
"-",
"this",
"url",
"path",
";",
"}",
"else",
"{",
"return",
"other",
"target",
"request",
"params",
"size",
"(",
")",
"-",
"this",
"target",
"request",
"params",
"size",
"(",
")",
";",
"}",
"}"
] |
[
"configure",
"a",
"time",
"limit",
"(",
"in",
"milliseconds",
")",
"for",
"the",
"maximum",
"amount",
"of",
"a",
"time",
"allowed",
"when",
"sending",
"messages",
"to",
"a",
"web",
"socket",
"session",
"or",
"writing",
"to",
"an",
"http",
"response",
"when",
"sock",
"j",
"s",
"fallback",
"option",
"are",
"in",
"use",
"in",
"general",
"web",
"socket",
"servers",
"expect",
"that",
"messages",
"to",
"a",
"single",
"web",
"socket",
"session",
"are",
"sent",
"from",
"a",
"single",
"thread",
"at",
"a",
"time",
"this",
"is",
"automatically",
"guaranteed",
"when",
"using",
"{",
"@",
"code",
"@",
"enable",
"web",
"socket",
"message",
"broker",
"}",
"configuration",
"if",
"message",
"sending",
"is",
"slow",
",",
"or",
"at",
"least",
"slower",
"than",
"rate",
"of",
"messages",
"sending",
",",
"subsequent",
"messages",
"are",
"buffered",
"until",
"either",
"the",
"{",
"@",
"code",
"send",
"time",
"limit",
"}",
"or",
"the",
"{",
"@",
"code",
"send",
"buffer",
"size",
"limit",
"}",
"are",
"reached",
"at",
"which",
"point",
"the",
"session",
"state",
"is",
"cleared",
"and",
"an",
"attempt",
"is",
"made",
"to",
"close",
"the",
"session",
"note",
"that",
"the",
"session",
"time",
"limit",
"is",
"checked",
"only",
"on",
"attempts",
"to",
"send",
"additional",
"messages",
"so",
"if",
"only",
"a",
"single",
"message",
"is",
"sent",
"and",
"it",
"hangs",
",",
"the",
"session",
"will",
"not",
"time",
"out",
"until",
"another",
"message",
"is",
"sent",
"or",
"the",
"underlying",
"physical",
"socket",
"times",
"out",
"so",
"this",
"is",
"not",
"a",
"replacement",
"for",
"web",
"socket",
"server",
"or",
"http",
"connection",
"timeout",
"but",
"is",
"rather",
"intended",
"to",
"control",
"the",
"extent",
"of",
"buffering",
"of",
"unsent",
"messages",
"note",
"that",
"closing",
"the",
"session",
"may",
"not",
"succeed",
"in",
"actually",
"closing",
"the",
"physical",
"socket",
"and",
"may",
"also",
"hang",
"this",
"is",
"true",
"especially",
"when",
"using",
"blocking",
"io",
"such",
"as",
"the",
"bio",
"connector",
"in",
"tomcat",
"that",
"is",
"used",
"by",
"default",
"on",
"tomcat",
"7",
"therefore",
"it",
"is",
"recommended",
"to",
"ensure",
"the",
"server",
"is",
"using",
"non",
"-",
"blocking",
"io",
"such",
"as",
"tomcat",
"'",
"s",
"nio",
"connector",
"that",
"is",
"used",
"by",
"default",
"on",
"tomcat",
"8",
"if",
"you",
"must",
"use",
"blocking",
"io",
"consider",
"customizing",
"os",
"-",
"level",
"tcp",
"settings",
",",
"for",
"example",
"{",
"@",
"code",
"procsysnetipv",
"4tcp",
"retries",
"2",
"}",
"on",
"linux",
"the",
"default",
"value",
"is",
"10",
"seconds",
"(",
"i",
"e",
"10",
"1000",
")"
] |
[
"public",
"web",
"socket",
"transport",
"registration",
"set",
"send",
"time",
"limit",
"(",
"int",
"time",
"limit",
")",
"{",
"this",
"send",
"time",
"limit",
"=",
"time",
"limit",
";",
"return",
"this",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"public",
"long",
"get",
"physical",
"memory",
"size",
"(",
")",
"{",
"read",
"proc",
"mem",
"info",
"file",
"(",
")",
";",
"return",
"(",
"ram",
"size",
"-",
"hardware",
"corrupt",
"size",
"-",
"(",
"huge",
"pages",
"total",
"*",
"huge",
"page",
"size",
")",
")",
"*",
"1024",
";",
"}"
] |
[
"get",
"date",
"time"
] |
[
"public",
"offset",
"date",
"time",
"get",
"date",
"time",
"(",
")",
"{",
"return",
"date",
"time",
";",
"}"
] |
[
"specify",
"whether",
"this",
"factory",
"bean",
"should",
"expose",
"an",
"unconfigurable",
"decorator",
"for",
"the",
"created",
"executor",
"default",
"is",
"\"",
"false",
"\"",
",",
"exposing",
"the",
"raw",
"executor",
"as",
"bean",
"reference",
"switch",
"this",
"flag",
"to",
"\"",
"true",
"\"",
"to",
"strictly",
"prevent",
"clients",
"from",
"modifying",
"the",
"executor",
"'",
"s",
"configuration"
] |
[
"public",
"void",
"set",
"expose",
"unconfigurable",
"executor",
"(",
"boolean",
"expose",
"unconfigurable",
"executor",
")",
"{",
"this",
"expose",
"unconfigurable",
"executor",
"=",
"expose",
"unconfigurable",
"executor",
";",
"}"
] |
[
"return",
"the",
"density",
"of",
"screen"
] |
[
"public",
"static",
"float",
"get",
"screen",
"density",
"(",
")",
"{",
"return",
"resources",
"get",
"system",
"(",
")",
"get",
"display",
"metrics",
"(",
")",
"density",
";",
"}"
] |
[
"returns",
"the",
"type"
] |
[
"public",
"string",
"get",
"type",
"(",
"clazz",
"clazz",
")",
"{",
"return",
"clazz",
"get",
"string",
"(",
"u",
"2type",
"index",
")",
";",
"}"
] |
[
"await",
"termination",
"on",
"the",
"main",
"thread",
"since",
"the",
"grpc",
"library",
"uses",
"daemon",
"threads"
] |
[
"private",
"void",
"block",
"until",
"shutdown",
"(",
")",
"throws",
"interrupted",
"exception",
"{",
"if",
"(",
"server",
"!",
"=",
"null",
")",
"{",
"server",
"await",
"termination",
"(",
")",
";",
"}",
"}"
] |
[
"get",
"all",
"instance",
"from",
"input",
"clusters"
] |
[
"public",
"list",
"<",
"instance",
">",
"srv",
"i",
"ps",
"(",
"list",
"<",
"string",
">",
"clusters",
")",
"{",
"if",
"(",
"collection",
"utils",
"is",
"empty",
"(",
"clusters",
")",
")",
"{",
"clusters",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"clusters",
"add",
"all",
"(",
"cluster",
"map",
"key",
"set",
"(",
")",
")",
";",
"}",
"return",
"all",
"i",
"ps",
"(",
"clusters",
")",
";",
"}"
] |
[
"starting",
"a",
"name",
"with",
"underscore",
",",
"so",
"that",
"the",
"user",
"cannot",
"access",
"this",
"function",
"directly",
"through",
"a",
"script",
"it",
"is",
"only",
"used",
"within",
"predefined",
"painless",
"functions"
] |
[
"public",
"int",
"get",
"doc",
"id",
"(",
")",
"{",
"return",
"doc",
"id",
";",
"}"
] |
[
"always",
"serialize",
"this",
"parameter",
",",
"no",
"matter",
"its",
"value"
] |
[
"public",
"parameter",
"<",
"t",
">",
"always",
"serialize",
"(",
")",
"{",
"this",
"serializer",
"check",
"=",
"(",
"id",
",",
"ic",
",",
"v",
")",
"-",
">",
"true",
";",
"return",
"this",
";",
"}"
] |
[
"returns",
"the",
"name",
"of",
"the",
"corrupted",
"file"
] |
[
"public",
"string",
"get",
"file",
"(",
")",
"{",
"return",
"filename",
";",
"}"
] |
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"the",
"exclusion",
"{",
"@",
"link",
"pattern",
"}",
"at",
"index",
"{",
"@",
"code",
"pattern",
"index",
"}",
"matches",
"the",
"supplied",
"candidate",
"{",
"@",
"code",
"string",
"}"
] |
[
"protected",
"boolean",
"matches",
"exclusion",
"(",
"string",
"candidate",
",",
"int",
"pattern",
"index",
")",
"{",
"matcher",
"matcher",
"=",
"this",
"compiled",
"exclusion",
"patterns",
"[",
"pattern",
"index",
"]",
"matcher",
"(",
"candidate",
")",
";",
"return",
"matcher",
"matches",
"(",
")",
";",
"}"
] |
[
"add",
"a",
"new",
"saved",
"jdbc",
"connection",
"configuration"
] |
[
"public",
"void",
"do",
"post",
"(",
"http",
"servlet",
"request",
"request",
",",
"http",
"servlet",
"response",
"response",
")",
"throws",
"servlet",
"exception",
",",
"i",
"o",
"exception",
"{",
"if",
"(",
"!",
"has",
"valid",
"c",
"s",
"r",
"f",
"token",
"(",
"request",
")",
")",
"{",
"respond",
"c",
"s",
"r",
"f",
"error",
"(",
"response",
")",
";",
"return",
";",
"}",
"if",
"(",
"logger",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"logger",
"debug",
"(",
"\"",
"do",
"post",
"connection",
":",
"{",
"}",
"\"",
",",
"request",
"get",
"parameter",
"(",
"\"",
"connection",
"name",
"\"",
")",
")",
";",
"}",
"database",
"configuration",
"jdbc",
"config",
"=",
"get",
"jdbc",
"configuration",
"(",
"request",
")",
";",
"response",
"set",
"character",
"encoding",
"(",
"\"",
"utf",
"-",
"8",
"\"",
")",
";",
"response",
"set",
"header",
"(",
"\"",
"content",
"-",
"type",
"\"",
",",
"\"",
"application",
"/",
"json",
"\"",
")",
";",
"if",
"(",
"jdbc",
"config",
"get",
"connection",
"name",
"(",
")",
"=",
"=",
"null",
")",
"{",
"response",
"send",
"error",
"(",
"http",
"status",
"sc",
"bad",
"request",
",",
"\"",
"connection",
"name",
"is",
"required",
"!",
"\"",
")",
";",
"response",
"flush",
"buffer",
"(",
")",
";",
"return",
";",
"}",
"if",
"(",
"!",
"validate",
"input",
"(",
"jdbc",
"config",
"get",
"connection",
"name",
"(",
")",
",",
"conn",
"name",
"pattern",
")",
")",
"{",
"logger",
"warn",
"(",
"\"",
"invalid",
"connection",
"name",
":",
"{",
"}",
"\"",
",",
"jdbc",
"config",
"get",
"connection",
"name",
"(",
")",
")",
";",
"response",
"send",
"error",
"(",
"http",
"status",
"sc",
"bad",
"request",
",",
"\"",
"connection",
"name",
"is",
"invalid",
"expecting",
"[",
"a",
"-",
"z",
"a",
"-",
"z0",
"-",
"9",
"-",
"]",
"\"",
")",
";",
"response",
"flush",
"buffer",
"(",
")",
";",
"return",
";",
"}",
"if",
"(",
"!",
"validate",
"input",
"(",
"\"",
"\"",
"+",
"jdbc",
"config",
"get",
"database",
"port",
"(",
")",
",",
"database",
"port",
"pattern",
")",
")",
"{",
"logger",
"warn",
"(",
"\"",
"invalid",
"database",
"port",
":",
"{",
"}",
"\"",
",",
"jdbc",
"config",
"get",
"database",
"port",
"(",
")",
")",
";",
"response",
"send",
"error",
"(",
"http",
"status",
"sc",
"bad",
"request",
",",
"\"",
"database",
"port",
"invalid",
"expecting",
"numeric",
"values",
"only",
"\"",
")",
";",
"response",
"flush",
"buffer",
"(",
")",
";",
"return",
";",
"}",
"database",
"configuration",
"saved",
"conn",
"=",
"database",
"utils",
"get",
"saved",
"connection",
"(",
"jdbc",
"config",
"get",
"connection",
"name",
"(",
")",
")",
";",
"if",
"(",
"saved",
"conn",
"!",
"=",
"null",
")",
"{",
"response",
"send",
"error",
"(",
"http",
"status",
"sc",
"bad",
"request",
",",
"\"",
"connection",
"with",
"name",
"\"",
"+",
"jdbc",
"config",
"get",
"connection",
"name",
"(",
")",
"+",
"\"",
"already",
"exists",
"!",
"\"",
")",
";",
"response",
"flush",
"buffer",
"(",
")",
";",
"return",
";",
"}",
"if",
"(",
"jdbc",
"config",
"get",
"database",
"password",
"(",
")",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"logger",
"debug",
"(",
"\"",
"saved",
"connection",
"command",
":",
":",
"post",
":",
":",
"password",
":",
":",
"{",
"}",
"\"",
",",
"jdbc",
"config",
"get",
"database",
"password",
"(",
")",
")",
";",
"jdbc",
"config",
"set",
"database",
"password",
"(",
"database",
"utils",
"encrypt",
"(",
"jdbc",
"config",
"get",
"database",
"password",
"(",
")",
")",
")",
";",
"}",
"database",
"utils",
"add",
"to",
"saved",
"connections",
"(",
"jdbc",
"config",
")",
";",
"try",
"{",
"response",
"set",
"character",
"encoding",
"(",
"\"",
"utf",
"-",
"8",
"\"",
")",
";",
"response",
"set",
"header",
"(",
"\"",
"content",
"-",
"type",
"\"",
",",
"\"",
"application",
"/",
"json",
"\"",
")",
";",
"write",
"saved",
"connection",
"response",
"(",
"response",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"logger",
"error",
"(",
"\"",
"exception",
"while",
"loading",
"settings",
"{",
"}",
"\"",
",",
"e",
")",
";",
"}",
"}"
] |
[
"retrieves",
"a",
"string",
"representing",
"the",
"state",
"of",
"the",
"job",
"queue",
"intended",
"for",
"debugging"
] |
[
"public",
"@",
"non",
"null",
"string",
"get",
"debug",
"info",
"(",
")",
"{",
"atomic",
"reference",
"<",
"string",
">",
"result",
"=",
"new",
"atomic",
"reference",
"<",
">",
"(",
")",
";",
"count",
"down",
"latch",
"latch",
"=",
"new",
"count",
"down",
"latch",
"(",
"1",
")",
";",
"run",
"on",
"executor",
"(",
"(",
")",
"-",
">",
"{",
"result",
"set",
"(",
"job",
"controller",
"get",
"debug",
"info",
"(",
")",
")",
";",
"latch",
"count",
"down",
"(",
")",
";",
"}",
")",
";",
"try",
"{",
"boolean",
"finished",
"=",
"latch",
"await",
"(",
"10",
",",
"time",
"unit",
"seconds",
")",
";",
"if",
"(",
"finished",
")",
"{",
"return",
"result",
"get",
"(",
")",
";",
"}",
"else",
"{",
"return",
"\"",
"timed",
"out",
"waiting",
"for",
"job",
"info",
"\"",
";",
"}",
"}",
"catch",
"(",
"interrupted",
"exception",
"e",
")",
"{",
"log",
"w",
"(",
"tag",
",",
"\"",
"failed",
"to",
"retrieve",
"job",
"info",
"\"",
",",
"e",
")",
";",
"return",
"\"",
"failed",
"to",
"retrieve",
"job",
"info",
"\"",
";",
"}",
"}"
] |
[
"validates",
"the",
"header",
"of",
"the",
"first",
"batch",
"and",
"returns",
"batch",
"size"
] |
[
"public",
"integer",
"first",
"batch",
"size",
"(",
")",
"{",
"if",
"(",
"buffer",
"remaining",
"(",
")",
"<",
"header",
"size",
"up",
"to",
"magic",
")",
"return",
"null",
";",
"return",
"new",
"byte",
"buffer",
"log",
"input",
"stream",
"(",
"buffer",
",",
"integer",
"max",
"value",
")",
"next",
"batch",
"size",
"(",
")",
";",
"}"
] |
[
"add",
"a",
"snapshot"
] |
[
"public",
"snapshot",
"add",
"snapshot",
"(",
"snapshot",
"manager",
"snapshot",
"manager",
",",
"string",
"name",
",",
"final",
"lease",
"manager",
"lease",
"manager",
",",
"long",
"mtime",
")",
"throws",
"snapshot",
"exception",
"{",
"return",
"get",
"directory",
"snapshottable",
"feature",
"(",
")",
"add",
"snapshot",
"(",
"this",
",",
"snapshot",
"manager",
",",
"name",
",",
"lease",
"manager",
",",
"mtime",
")",
";",
"}"
] |
[
"create",
"old",
"-",
"language",
"file",
"for",
"the",
"specified",
"language"
] |
[
"public",
"static",
"void",
"create",
"old",
"language",
"file",
"(",
"language",
"lang",
",",
"file",
"file",
")",
"throws",
"i",
"o",
"exception",
",",
"language",
"not",
"found",
"exception",
"{",
"language",
"service",
"language",
"service",
"=",
"default",
"language",
"service",
"get",
"language",
"service",
"(",
")",
";",
"if",
"(",
"lang",
"instanceof",
"old",
"language",
")",
"{",
"throw",
"new",
"language",
"not",
"found",
"exception",
"(",
"\"",
"can",
"'",
"t",
"create",
"an",
"old",
"langauge",
"file",
"from",
"an",
"old",
"language",
"\"",
")",
";",
"}",
"language",
"description",
"language",
"description",
"=",
"language",
"service",
"get",
"language",
"description",
"(",
"lang",
"get",
"language",
"i",
"d",
"(",
")",
")",
";",
"element",
"root",
"=",
"new",
"element",
"(",
"\"",
"language",
"\"",
")",
";",
"root",
"set",
"attribute",
"(",
"\"",
"version",
"\"",
",",
"integer",
"to",
"string",
"(",
"lang",
"get",
"version",
"(",
")",
")",
")",
";",
"root",
"set",
"attribute",
"(",
"\"",
"endian",
"\"",
",",
"lang",
"is",
"big",
"endian",
"(",
")",
"?",
"\"",
"big",
"\"",
":",
"\"",
"little",
"\"",
")",
";",
"root",
"add",
"content",
"(",
"get",
"description",
"element",
"(",
"language",
"description",
")",
")",
";",
"for",
"(",
"compiler",
"spec",
"description",
"cs",
":",
"lang",
"get",
"compatible",
"compiler",
"spec",
"descriptions",
"(",
")",
")",
"{",
"element",
"compiler",
"element",
"=",
"new",
"element",
"(",
"\"",
"compiler",
"\"",
")",
";",
"compiler",
"element",
"set",
"attribute",
"(",
"\"",
"name",
"\"",
",",
"cs",
"get",
"compiler",
"spec",
"name",
"(",
")",
")",
";",
"compiler",
"element",
"set",
"attribute",
"(",
"\"",
"id",
"\"",
",",
"cs",
"get",
"compiler",
"spec",
"i",
"d",
"(",
")",
"get",
"id",
"as",
"string",
"(",
")",
")",
";",
"root",
"add",
"content",
"(",
"compiler",
"element",
")",
";",
"}",
"root",
"add",
"content",
"(",
"get",
"spaces",
"element",
"(",
"lang",
")",
")",
";",
"root",
"add",
"content",
"(",
"get",
"registers",
"element",
"(",
"lang",
")",
")",
";",
"document",
"doc",
"=",
"new",
"document",
"(",
"root",
")",
";",
"file",
"output",
"stream",
"out",
"=",
"new",
"file",
"output",
"stream",
"(",
"file",
")",
";",
"x",
"m",
"l",
"outputter",
"xml",
"=",
"new",
"generic",
"x",
"m",
"l",
"outputter",
"(",
")",
";",
"xml",
"output",
"(",
"doc",
",",
"out",
")",
";",
"out",
"close",
"(",
")",
";",
"}"
] |
[
"checks",
"if",
"this",
"instance",
"and",
"the",
"given",
"instance",
"share",
"the",
"same",
"repositories",
"by",
"checking",
"that",
"this",
"instances",
"'",
"repositories",
"and",
"the",
"repositories",
"in",
"{",
"@",
"code",
"other",
"}",
"are",
"equal",
"or",
"only",
"differ",
"in",
"their",
"values",
"of",
"{",
"@",
"link",
"repository",
"metadata",
"#",
"generation",
"(",
")",
"}",
"and",
"{",
"@",
"link",
"repository",
"metadata",
"#",
"pending",
"generation",
"(",
")",
"}"
] |
[
"public",
"boolean",
"equals",
"ignore",
"generations",
"(",
"@",
"nullable",
"repositories",
"metadata",
"other",
")",
"{",
"if",
"(",
"other",
"=",
"=",
"null",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"other",
"repositories",
"size",
"(",
")",
"!",
"=",
"repositories",
"size",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"repositories",
"size",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"repositories",
"get",
"(",
"i",
")",
"equals",
"ignore",
"generations",
"(",
"other",
"repositories",
"get",
"(",
"i",
")",
")",
"=",
"=",
"false",
")",
"{",
"return",
"false",
";",
"}",
"}",
"return",
"true",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.