docstring_tokens
sequence | code_tokens
sequence |
|---|---|
[
"one",
"empty",
"request",
"followed",
"by",
"one",
"empty",
"response"
] | [
"public",
"void",
"empty",
"call",
"(",
"io",
"grpc",
"testing",
"integration",
"empty",
"protos",
"empty",
"request",
",",
"io",
"grpc",
"stub",
"stream",
"observer",
"<",
"io",
"grpc",
"testing",
"integration",
"empty",
"protos",
"empty",
">",
"response",
"observer",
")",
"{",
"io",
"grpc",
"stub",
"server",
"calls",
"async",
"unimplemented",
"unary",
"call",
"(",
"get",
"empty",
"call",
"method",
"(",
")",
",",
"response",
"observer",
")",
";",
"}"
] |
[
"locates",
"the",
"index",
"for",
"the",
"given",
"key",
"this",
"method",
"probes",
"using",
"double",
"hashing"
] | [
"private",
"int",
"index",
"of",
"(",
"long",
"key",
")",
"{",
"int",
"start",
"index",
"=",
"hash",
"index",
"(",
"key",
")",
";",
"int",
"index",
"=",
"start",
"index",
";",
"for",
"(",
";",
";",
")",
"{",
"if",
"(",
"values",
"[",
"index",
"]",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"it",
"'",
"s",
"available",
",",
"so",
"no",
"chance",
"that",
"this",
"value",
"exists",
"anywhere",
"in",
"the",
"map",
"return",
"-",
"1",
";",
"}",
"if",
"(",
"key",
"=",
"=",
"keys",
"[",
"index",
"]",
")",
"{",
"return",
"index",
";",
"}",
"/",
"/",
"conflict",
",",
"keep",
"probing",
"if",
"(",
"(",
"index",
"=",
"probe",
"next",
"(",
"index",
")",
")",
"=",
"=",
"start",
"index",
")",
"{",
"return",
"-",
"1",
";",
"}",
"}",
"}"
] |
[
"load",
"the",
"first",
"-",
"found",
"specific",
"spi",
"instance"
] | [
"public",
"static",
"<",
"t",
">",
"t",
"load",
"first",
"instance",
"(",
"class",
"<",
"t",
">",
"clazz",
")",
"{",
"assert",
"util",
"not",
"null",
"(",
"clazz",
",",
"\"",
"spi",
"class",
"cannot",
"be",
"null",
"\"",
")",
";",
"try",
"{",
"string",
"key",
"=",
"clazz",
"get",
"name",
"(",
")",
";",
"/",
"/",
"not",
"thread",
"-",
"safe",
",",
"as",
"it",
"'",
"s",
"expected",
"to",
"be",
"resolved",
"in",
"a",
"thread",
"-",
"safe",
"context",
"service",
"loader",
"<",
"t",
">",
"service",
"loader",
"=",
"service",
"loader",
"map",
"get",
"(",
"key",
")",
";",
"if",
"(",
"service",
"loader",
"=",
"=",
"null",
")",
"{",
"service",
"loader",
"=",
"service",
"loader",
"util",
"get",
"service",
"loader",
"(",
"clazz",
")",
";",
"service",
"loader",
"map",
"put",
"(",
"key",
",",
"service",
"loader",
")",
";",
"}",
"iterator",
"<",
"t",
">",
"iterator",
"=",
"service",
"loader",
"iterator",
"(",
")",
";",
"if",
"(",
"iterator",
"has",
"next",
"(",
")",
")",
"{",
"return",
"iterator",
"next",
"(",
")",
";",
"}",
"else",
"{",
"return",
"null",
";",
"}",
"}",
"catch",
"(",
"throwable",
"t",
")",
"{",
"record",
"log",
"error",
"(",
"\"",
"[",
"spi",
"loader",
"]",
"error",
":",
"load",
"first",
"instance",
"failed",
"\"",
",",
"t",
")",
";",
"t",
"print",
"stack",
"trace",
"(",
")",
";",
"return",
"null",
";",
"}",
"}"
] |
[
"flatten",
"inline",
"models",
"in",
"request",
"body"
] | [
"private",
"void",
"flatten",
"request",
"body",
"(",
"open",
"a",
"p",
"i",
"open",
"a",
"p",
"i",
",",
"string",
"pathname",
",",
"operation",
"operation",
")",
"{",
"request",
"body",
"request",
"body",
"=",
"operation",
"get",
"request",
"body",
"(",
")",
";",
"if",
"(",
"request",
"body",
"=",
"=",
"null",
")",
"{",
"return",
";",
"}",
"schema",
"model",
"=",
"model",
"utils",
"get",
"schema",
"from",
"request",
"body",
"(",
"request",
"body",
")",
";",
"if",
"(",
"model",
"instanceof",
"object",
"schema",
")",
"{",
"schema",
"obj",
"=",
"(",
"schema",
")",
"model",
";",
"if",
"(",
"obj",
"get",
"type",
"(",
")",
"=",
"=",
"null",
"|",
"|",
"\"",
"object",
"\"",
"equals",
"(",
"obj",
"get",
"type",
"(",
")",
")",
")",
"{",
"if",
"(",
"obj",
"get",
"properties",
"(",
")",
"!",
"=",
"null",
"&",
"&",
"obj",
"get",
"properties",
"(",
")",
"size",
"(",
")",
">",
"0",
")",
"{",
"flatten",
"properties",
"(",
"open",
"a",
"p",
"i",
",",
"obj",
"get",
"properties",
"(",
")",
",",
"pathname",
")",
";",
"/",
"/",
"for",
"model",
"name",
",",
"use",
"\"",
"title",
"\"",
"if",
"defined",
",",
"otherwise",
"default",
"to",
"'",
"inline",
"object",
"'",
"string",
"model",
"name",
"=",
"resolve",
"model",
"name",
"(",
"obj",
"get",
"title",
"(",
")",
",",
"\"",
"inline",
"object",
"\"",
")",
";",
"add",
"generated",
"(",
"model",
"name",
",",
"model",
")",
";",
"open",
"a",
"p",
"i",
"get",
"components",
"(",
")",
"add",
"schemas",
"(",
"model",
"name",
",",
"model",
")",
";",
"/",
"/",
"create",
"request",
"body",
"request",
"body",
"rb",
"=",
"new",
"request",
"body",
"(",
")",
";",
"rb",
"set",
"required",
"(",
"request",
"body",
"get",
"required",
"(",
")",
")",
";",
"content",
"content",
"=",
"new",
"content",
"(",
")",
";",
"media",
"type",
"mt",
"=",
"new",
"media",
"type",
"(",
")",
";",
"schema",
"schema",
"=",
"new",
"schema",
"(",
")",
";",
"schema",
"set",
"$",
"ref",
"(",
"model",
"name",
")",
";",
"mt",
"set",
"schema",
"(",
"schema",
")",
";",
"/",
"/",
"get",
"\"",
"consumes",
"\"",
",",
"e",
"g",
"application",
"/",
"xml",
",",
"application",
"/",
"json",
"set",
"<",
"string",
">",
"consumes",
";",
"if",
"(",
"request",
"body",
"=",
"=",
"null",
"|",
"|",
"request",
"body",
"get",
"content",
"(",
")",
"=",
"=",
"null",
"|",
"|",
"request",
"body",
"get",
"content",
"(",
")",
"is",
"empty",
"(",
")",
")",
"{",
"consumes",
"=",
"new",
"hash",
"set",
"<",
">",
"(",
")",
";",
"consumes",
"add",
"(",
"\"",
"application",
"/",
"json",
"\"",
")",
";",
"/",
"/",
"default",
"to",
"application",
"/",
"json",
"logger",
"info",
"(",
"\"",
"default",
"to",
"application",
"/",
"json",
"for",
"inline",
"body",
"schema",
"\"",
")",
";",
"}",
"else",
"{",
"consumes",
"=",
"request",
"body",
"get",
"content",
"(",
")",
"key",
"set",
"(",
")",
";",
"}",
"for",
"(",
"string",
"consume",
":",
"consumes",
")",
"{",
"content",
"add",
"media",
"type",
"(",
"consume",
",",
"mt",
")",
";",
"}",
"rb",
"set",
"content",
"(",
"content",
")",
";",
"/",
"/",
"add",
"to",
"openapi",
"\"",
"components",
"\"",
"if",
"(",
"open",
"a",
"p",
"i",
"get",
"components",
"(",
")",
"get",
"request",
"bodies",
"(",
")",
"=",
"=",
"null",
")",
"{",
"map",
"<",
"string",
",",
"request",
"body",
">",
"request",
"bodies",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"request",
"body",
">",
"(",
")",
";",
"request",
"bodies",
"put",
"(",
"model",
"name",
",",
"rb",
")",
";",
"open",
"a",
"p",
"i",
"get",
"components",
"(",
")",
"set",
"request",
"bodies",
"(",
"request",
"bodies",
")",
";",
"}",
"else",
"{",
"open",
"a",
"p",
"i",
"get",
"components",
"(",
")",
"get",
"request",
"bodies",
"(",
")",
"put",
"(",
"model",
"name",
",",
"rb",
")",
";",
"}",
"/",
"/",
"update",
"request",
"body",
"to",
"use",
"$",
"ref",
"instead",
"of",
"inline",
"def",
"request",
"body",
"set",
"$",
"ref",
"(",
"model",
"name",
")",
";",
"}",
"}",
"}",
"else",
"if",
"(",
"model",
"instanceof",
"array",
"schema",
")",
"{",
"array",
"schema",
"am",
"=",
"(",
"array",
"schema",
")",
"model",
";",
"schema",
"inner",
"=",
"am",
"get",
"items",
"(",
")",
";",
"if",
"(",
"inner",
"instanceof",
"object",
"schema",
")",
"{",
"object",
"schema",
"op",
"=",
"(",
"object",
"schema",
")",
"inner",
";",
"if",
"(",
"op",
"get",
"properties",
"(",
")",
"!",
"=",
"null",
"&",
"&",
"op",
"get",
"properties",
"(",
")",
"size",
"(",
")",
">",
"0",
")",
"{",
"flatten",
"properties",
"(",
"open",
"a",
"p",
"i",
",",
"op",
"get",
"properties",
"(",
")",
",",
"pathname",
")",
";",
"/",
"/",
"generate",
"a",
"unique",
"model",
"name",
"based",
"on",
"the",
"title",
"string",
"model",
"name",
"=",
"resolve",
"model",
"name",
"(",
"op",
"get",
"title",
"(",
")",
",",
"null",
")",
";",
"schema",
"inner",
"model",
"=",
"model",
"from",
"property",
"(",
"open",
"a",
"p",
"i",
",",
"op",
",",
"model",
"name",
")",
";",
"string",
"existing",
"=",
"match",
"generated",
"(",
"inner",
"model",
")",
";",
"if",
"(",
"existing",
"!",
"=",
"null",
")",
"{",
"schema",
"schema",
"=",
"new",
"schema",
"(",
")",
"$",
"ref",
"(",
"existing",
")",
";",
"schema",
"set",
"required",
"(",
"op",
"get",
"required",
"(",
")",
")",
";",
"am",
"set",
"items",
"(",
"schema",
")",
";",
"}",
"else",
"{",
"schema",
"schema",
"=",
"new",
"schema",
"(",
")",
"$",
"ref",
"(",
"model",
"name",
")",
";",
"schema",
"set",
"required",
"(",
"op",
"get",
"required",
"(",
")",
")",
";",
"am",
"set",
"items",
"(",
"schema",
")",
";",
"add",
"generated",
"(",
"model",
"name",
",",
"inner",
"model",
")",
";",
"open",
"a",
"p",
"i",
"get",
"components",
"(",
")",
"add",
"schemas",
"(",
"model",
"name",
",",
"inner",
"model",
")",
";",
"}",
"}",
"}",
"}",
"}"
] |
[
"returns",
"the",
"operating",
"system",
"architecture"
] | [
"public",
"static",
"string",
"get",
"os",
"architecture",
"(",
")",
"{",
"return",
"os",
"bean",
"get",
"arch",
"(",
")",
";",
"}"
] |
[
"get",
"array",
"number"
] | [
"public",
"list",
"<",
"big",
"decimal",
">",
"get",
"array",
"number",
"(",
")",
"{",
"return",
"array",
"number",
";",
"}"
] |
[
"returns",
"the",
"signed",
"current",
"selection",
"the",
"length",
"will",
"be",
"negative",
"if",
"the",
"resulting",
"selection",
"is",
"right",
"-",
"to",
"-",
"left",
"the",
"selection",
"offset",
"is",
"model",
"based"
] | [
"private",
"static",
"final",
"i",
"region",
"get",
"signed",
"selection",
"(",
"i",
"source",
"viewer",
"source",
"viewer",
")",
"{",
"point",
"viewer",
"selection",
"=",
"source",
"viewer",
"get",
"selected",
"range",
"(",
")",
";",
"styled",
"text",
"text",
"=",
"source",
"viewer",
"get",
"text",
"widget",
"(",
")",
";",
"point",
"selection",
"=",
"text",
"get",
"selection",
"range",
"(",
")",
";",
"if",
"(",
"text",
"get",
"caret",
"offset",
"(",
")",
"=",
"=",
"selection",
"x",
")",
"{",
"viewer",
"selection",
"x",
"=",
"viewer",
"selection",
"x",
"+",
"viewer",
"selection",
"y",
";",
"viewer",
"selection",
"y",
"=",
"-",
"viewer",
"selection",
"y",
";",
"}",
"return",
"new",
"region",
"(",
"viewer",
"selection",
"x",
",",
"viewer",
"selection",
"y",
")",
";",
"}"
] |
[
"get",
"auth",
"plugin",
"data"
] | [
"public",
"byte",
"[",
"]",
"get",
"auth",
"plugin",
"data",
"(",
")",
"{",
"return",
"bytes",
"concat",
"(",
"auth",
"plugin",
"data",
"part",
"1",
",",
"auth",
"plugin",
"data",
"part",
"2",
")",
";",
"}"
] |
[
"reads",
"the",
"map",
"entries",
"from",
"the",
"specified",
"data",
"input",
"stream"
] | [
"private",
"void",
"read",
"entries",
"(",
"data",
"input",
"stream",
"in",
",",
"boolean",
"fail",
"fast",
")",
"throws",
"i",
"o",
"exception",
"{",
"map",
"<",
"k",
",",
"v",
">",
"map",
"=",
"delegate",
"(",
")",
";",
"while",
"(",
"has",
"entries",
"(",
"in",
",",
"fail",
"fast",
")",
")",
"{",
"k",
"key",
"=",
"read",
"key",
"(",
"in",
")",
";",
"boolean",
"is",
"entry",
"=",
"in",
"read",
"boolean",
"(",
")",
";",
"if",
"(",
"is",
"entry",
")",
"{",
"v",
"value",
"=",
"read",
"value",
"(",
"in",
")",
";",
"map",
"put",
"(",
"key",
",",
"value",
")",
";",
"}",
"else",
"{",
"map",
"remove",
"(",
"key",
")",
";",
"}",
"}",
"}"
] |
[
"kicks",
"off",
"a",
"lookup",
"for",
"the",
"given",
"{",
"@",
"code",
"client",
"hello",
"}",
"and",
"returns",
"a",
"{",
"@",
"link",
"future",
"}",
"which",
"in",
"turn",
"will",
"notify",
"the",
"{",
"@",
"link",
"#",
"on",
"lookup",
"complete",
"(",
"channel",
"handler",
"context",
",",
"future",
")",
"}",
"on",
"completion",
"see",
"https",
":",
"tools",
"ietf",
"orghtmlrfc",
"5",
"2",
"4",
"6",
"#",
"section",
"-",
"7",
"4",
"1",
"2",
"struct",
"{",
"protocol",
"version",
"client",
"version",
";",
"random",
"random",
";",
"session",
"i",
"d",
"session",
"id",
";",
"cipher",
"suite",
"cipher",
"suites",
"<",
"2",
"2",
"^",
"16",
"-",
"2",
">",
";",
"compression",
"method",
"compression",
"methods",
"<",
"1",
"2",
"^",
"8",
"-",
"1",
">",
";",
"select",
"(",
"extensions",
"present",
")",
"{",
"case",
"false",
":",
"struct",
"{",
"}",
";",
"case",
"true",
":",
"extension",
"extensions",
"<",
"0",
"2",
"^",
"16",
"-",
"1",
">",
";",
"}",
";",
"}",
"client",
"hello",
";"
] | [
"protected",
"abstract",
"future",
"<",
"t",
">",
"lookup",
"(",
"channel",
"handler",
"context",
"ctx",
",",
"byte",
"buf",
"client",
"hello",
")",
"throws",
"exception",
";"
] |
[
"a",
"sensible",
"definition",
"of",
"{",
"@",
"link",
"#",
"lower",
"entry",
"}",
"in",
"terms",
"of",
"the",
"{",
"@",
"code",
"last",
"entry",
"(",
")",
"}",
"of",
"{",
"@",
"link",
"#",
"head",
"map",
"(",
"object",
",",
"boolean",
")",
"}",
"if",
"you",
"override",
"{",
"@",
"code",
"head",
"map",
"}",
",",
"you",
"may",
"wish",
"to",
"override",
"{",
"@",
"code",
"lower",
"entry",
"}",
"to",
"forward",
"to",
"this",
"implementation"
] | [
"protected",
"entry",
"<",
"k",
",",
"v",
">",
"standard",
"lower",
"entry",
"(",
"k",
"key",
")",
"{",
"return",
"head",
"map",
"(",
"key",
",",
"false",
")",
"last",
"entry",
"(",
")",
";",
"}"
] |
[
"returns",
"true",
"if",
"the",
"entry",
"is",
"a",
"class",
"file"
] | [
"public",
"boolean",
"is",
"class",
"(",
")",
"{",
"if",
"(",
"!",
"name",
"ends",
"with",
"(",
"\"",
"class",
"\"",
")",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"name",
"starts",
"with",
"(",
"\"",
"meta",
"-",
"inf",
"/",
"version",
"\"",
")",
")",
"{",
"/",
"/",
"todo",
"(",
"b",
"/",
"69678527",
")",
":",
"handle",
"multi",
"-",
"release",
"jar",
"files",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"attempt",
"to",
"stop",
"the",
"indexer",
"if",
"it",
"is",
"idle",
"or",
"actively",
"indexing",
"if",
"the",
"indexer",
"is",
"aborted",
"this",
"will",
"fail",
"with",
"an",
"exception",
"note",
"that",
"stopping",
"the",
"job",
"is",
"not",
"immediate",
"it",
"updates",
"the",
"persistent",
"task",
"'",
"s",
"status",
",",
"but",
"then",
"the",
"allocated",
"task",
"has",
"to",
"notice",
"and",
"stop",
"itself",
"(",
"which",
"may",
"take",
"some",
"time",
",",
"depending",
"on",
"where",
"in",
"the",
"indexing",
"cycle",
"it",
"is",
")",
"this",
"method",
"will",
",",
"however",
",",
"return",
"as",
"soon",
"as",
"the",
"persistent",
"task",
"has",
"acknowledge",
"the",
"status",
"update"
] | [
"public",
"synchronized",
"void",
"stop",
"(",
"action",
"listener",
"<",
"stop",
"rollup",
"job",
"action",
"response",
">",
"listener",
")",
"{",
"final",
"indexer",
"state",
"new",
"state",
"=",
"indexer",
"stop",
"(",
")",
";",
"switch",
"(",
"new",
"state",
")",
"{",
"case",
"stopped",
":",
"listener",
"on",
"response",
"(",
"new",
"stop",
"rollup",
"job",
"action",
"response",
"(",
"true",
")",
")",
";",
"break",
";",
"case",
"stopping",
":",
"/",
"/",
"update",
"the",
"persistent",
"state",
"to",
"stopped",
"there",
"are",
"two",
"scenarios",
"and",
"both",
"are",
"safe",
":",
"/",
"/",
"1",
"we",
"persist",
"stopped",
"now",
",",
"indexer",
"continues",
"a",
"bit",
"then",
"sees",
"the",
"flag",
"and",
"checkpoints",
"another",
"/",
"/",
"stopped",
"with",
"the",
"more",
"recent",
"position",
"/",
"/",
"2",
"we",
"persist",
"stopped",
"now",
",",
"indexer",
"continues",
"a",
"bit",
"but",
"then",
"dies",
"when",
"/",
"if",
"we",
"resume",
"we",
"'",
"ll",
"pick",
"up",
"/",
"/",
"at",
"last",
"checkpoint",
",",
"overwrite",
"some",
"docs",
"and",
"eventually",
"checkpoint",
"rollup",
"job",
"status",
"state",
"=",
"new",
"rollup",
"job",
"status",
"(",
"indexer",
"state",
"stopped",
",",
"indexer",
"get",
"position",
"(",
")",
")",
";",
"update",
"persistent",
"task",
"state",
"(",
"state",
",",
"action",
"listener",
"wrap",
"(",
"(",
"task",
")",
"-",
">",
"{",
"logger",
"debug",
"(",
"\"",
"successfully",
"updated",
"state",
"for",
"rollup",
"job",
"[",
"\"",
"+",
"job",
"get",
"config",
"(",
")",
"get",
"id",
"(",
")",
"+",
"\"",
"]",
"to",
"[",
"\"",
"+",
"state",
"get",
"indexer",
"state",
"(",
")",
"+",
"\"",
"]",
"\"",
")",
";",
"listener",
"on",
"response",
"(",
"new",
"stop",
"rollup",
"job",
"action",
"response",
"(",
"true",
")",
")",
";",
"}",
",",
"(",
"exc",
")",
"-",
">",
"{",
"listener",
"on",
"failure",
"(",
"new",
"elasticsearch",
"exception",
"(",
"\"",
"error",
"while",
"updating",
"state",
"for",
"rollup",
"job",
"[",
"\"",
"+",
"job",
"get",
"config",
"(",
")",
"get",
"id",
"(",
")",
"+",
"\"",
"]",
"to",
"[",
"\"",
"+",
"state",
"get",
"indexer",
"state",
"(",
")",
"+",
"\"",
"]",
"\"",
",",
"exc",
")",
")",
";",
"}",
")",
")",
";",
"break",
";",
"default",
":",
"listener",
"on",
"failure",
"(",
"new",
"elasticsearch",
"exception",
"(",
"\"",
"cannot",
"stop",
"task",
"for",
"rollup",
"job",
"[",
"\"",
"+",
"job",
"get",
"config",
"(",
")",
"get",
"id",
"(",
")",
"+",
"\"",
"]",
"because",
"\"",
"+",
"\"",
"state",
"was",
"[",
"\"",
"+",
"new",
"state",
"+",
"\"",
"]",
"\"",
")",
")",
";",
"break",
";",
"}",
"}"
] |
[
"locates",
"the",
"{",
"@",
"link",
"bean",
"definition",
"parser",
"}",
"from",
"the",
"register",
"implementations",
"using",
"the",
"local",
"name",
"of",
"the",
"supplied",
"{",
"@",
"link",
"element",
"}"
] | [
"private",
"bean",
"definition",
"parser",
"find",
"parser",
"for",
"element",
"(",
"element",
"element",
",",
"parser",
"context",
"parser",
"context",
")",
"{",
"string",
"local",
"name",
"=",
"parser",
"context",
"get",
"delegate",
"(",
")",
"get",
"local",
"name",
"(",
"element",
")",
";",
"bean",
"definition",
"parser",
"parser",
"=",
"this",
"parsers",
"get",
"(",
"local",
"name",
")",
";",
"if",
"(",
"parser",
"=",
"=",
"null",
")",
"{",
"parser",
"context",
"get",
"reader",
"context",
"(",
")",
"fatal",
"(",
"\"",
"cannot",
"locate",
"bean",
"definition",
"parser",
"for",
"element",
"[",
"\"",
"+",
"local",
"name",
"+",
"\"",
"]",
"\"",
",",
"element",
")",
";",
"}",
"return",
"parser",
";",
"}"
] |
[
"creates",
"a",
"new",
"initializing",
"shard",
"the",
"shard",
"will",
"will",
"be",
"put",
"in",
"its",
"proper",
"path",
"under",
"the",
"current",
"node",
"id",
"the",
"shard",
"is",
"assigned",
"to"
] | [
"protected",
"index",
"shard",
"new",
"shard",
"(",
"shard",
"routing",
"routing",
",",
"index",
"metadata",
"index",
"metadata",
",",
"@",
"nullable",
"checked",
"function",
"<",
"directory",
"reader",
",",
"directory",
"reader",
",",
"i",
"o",
"exception",
">",
"index",
"reader",
"wrapper",
",",
"engine",
"factory",
"engine",
"factory",
",",
"indexing",
"operation",
"listener",
"listeners",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"new",
"shard",
"(",
"routing",
",",
"index",
"metadata",
",",
"index",
"reader",
"wrapper",
",",
"engine",
"factory",
",",
"(",
")",
"-",
">",
"{",
"}",
",",
"retention",
"lease",
"syncer",
"empty",
",",
"listeners",
")",
";",
"}"
] |
[
"inflate",
"compressed",
"data",
"into",
"a",
"properly",
"sized",
"data",
"array"
] | [
"private",
"static",
"void",
"inflate",
"data",
"(",
"byte",
"[",
"]",
"compressed",
"data",
",",
"byte",
"[",
"]",
"data",
")",
"throws",
"i",
"o",
"exception",
"{",
"inflater",
"inflater",
"=",
"new",
"inflater",
"(",
"true",
")",
";",
"inflater",
"set",
"input",
"(",
"compressed",
"data",
",",
"0",
",",
"compressed",
"data",
"length",
")",
";",
"try",
"{",
"int",
"off",
"=",
"0",
";",
"while",
"(",
"!",
"inflater",
"finished",
"(",
")",
"&",
"&",
"off",
"<",
"data",
"length",
")",
"{",
"off",
"+",
"=",
"inflater",
"inflate",
"(",
"data",
",",
"off",
",",
"data",
"length",
"-",
"off",
")",
";",
"if",
"(",
"inflater",
"needs",
"dictionary",
"(",
")",
")",
"{",
"/",
"/",
"unexpected",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"data",
"buffer",
"dictionary",
"error",
"\"",
")",
";",
"}",
"}",
"if",
"(",
"!",
"inflater",
"finished",
"(",
")",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"data",
"buffer",
"inflate",
"size",
"error",
"\"",
")",
";",
"}",
"}",
"catch",
"(",
"data",
"format",
"exception",
"e",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"data",
"buffer",
"inflation",
"failed",
"\"",
",",
"e",
")",
";",
"}",
"}"
] |
[
"null",
"keys",
"aren",
"'",
"t",
"allowed",
"either"
] | [
"public",
"void",
"test",
"unique",
"index",
"null",
"key",
"(",
")",
"{",
"list",
"<",
"string",
">",
"one",
"string",
"list",
"=",
"lists",
"new",
"array",
"list",
"(",
"\"",
"foo",
"\"",
")",
";",
"try",
"{",
"maps",
"unique",
"index",
"(",
"one",
"string",
"list",
",",
"functions",
"constant",
"(",
"null",
")",
")",
";",
"fail",
"(",
")",
";",
"}",
"catch",
"(",
"null",
"pointer",
"exception",
"expected",
")",
"{",
"}",
"}"
] |
[
"records",
"that",
"the",
"current",
"thread",
"is",
"about",
"to",
"wait",
"on",
"the",
"specified",
"guard"
] | [
"private",
"void",
"begin",
"waiting",
"for",
"(",
"guard",
"guard",
")",
"{",
"int",
"waiters",
"=",
"guard",
"waiter",
"count",
"+",
"+",
";",
"if",
"(",
"waiters",
"=",
"=",
"0",
")",
"{",
"/",
"/",
"push",
"guard",
"onto",
"active",
"guards",
"guard",
"next",
"=",
"active",
"guards",
";",
"active",
"guards",
"=",
"guard",
";",
"}",
"}"
] |
[
"returns",
"a",
"string",
"in",
"the",
"format",
"specified",
"by",
"{",
"@",
"link",
"objects",
"#",
"to",
"string",
"helper",
"(",
"object",
")",
"}",
"after",
"calling",
"this",
"method",
",",
"you",
"can",
"keep",
"adding",
"more",
"properties",
"to",
"later",
"call",
"to",
"string",
"(",
")",
"again",
"and",
"get",
"a",
"more",
"complete",
"representation",
"of",
"the",
"same",
"object",
";",
"but",
"properties",
"cannot",
"be",
"removed",
",",
"so",
"this",
"only",
"allows",
"limited",
"reuse",
"of",
"the",
"helper",
"instance",
"the",
"helper",
"allows",
"duplication",
"of",
"properties",
"(",
"multiple",
"namevalue",
"pairs",
"with",
"the",
"same",
"name",
"can",
"be",
"added",
")"
] | [
"public",
"string",
"to",
"string",
"(",
")",
"{",
"/",
"/",
"create",
"a",
"copy",
"to",
"keep",
"it",
"consistent",
"in",
"case",
"value",
"changes",
"boolean",
"omit",
"null",
"values",
"snapshot",
"=",
"omit",
"null",
"values",
";",
"string",
"next",
"separator",
"=",
"\"",
"\"",
";",
"string",
"builder",
"builder",
"=",
"new",
"string",
"builder",
"(",
"32",
")",
"append",
"(",
"class",
"name",
")",
"append",
"(",
"'",
"{",
"'",
")",
";",
"for",
"(",
"value",
"holder",
"value",
"holder",
"=",
"holder",
"head",
"next",
";",
"value",
"holder",
"!",
"=",
"null",
";",
"value",
"holder",
"=",
"value",
"holder",
"next",
")",
"{",
"object",
"value",
"=",
"value",
"holder",
"value",
";",
"if",
"(",
"!",
"omit",
"null",
"values",
"snapshot",
"|",
"|",
"value",
"!",
"=",
"null",
")",
"{",
"builder",
"append",
"(",
"next",
"separator",
")",
";",
"next",
"separator",
"=",
"\"",
",",
"\"",
";",
"if",
"(",
"value",
"holder",
"name",
"!",
"=",
"null",
")",
"{",
"builder",
"append",
"(",
"value",
"holder",
"name",
")",
"append",
"(",
"'",
"=",
"'",
")",
";",
"}",
"if",
"(",
"value",
"!",
"=",
"null",
"&",
"&",
"value",
"get",
"class",
"(",
")",
"is",
"array",
"(",
")",
")",
"{",
"object",
"[",
"]",
"object",
"array",
"=",
"{",
"value",
"}",
";",
"string",
"array",
"string",
"=",
"arrays",
"deep",
"to",
"string",
"(",
"object",
"array",
")",
";",
"builder",
"append",
"(",
"array",
"string",
",",
"1",
",",
"array",
"string",
"length",
"(",
")",
"-",
"1",
")",
";",
"}",
"else",
"{",
"builder",
"append",
"(",
"value",
")",
";",
"}",
"}",
"}",
"return",
"builder",
"append",
"(",
"'",
"}",
"'",
")",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"sets",
"the",
"{",
"@",
"link",
"control",
"dispatcher",
"}"
] | [
"public",
"void",
"set",
"control",
"dispatcher",
"(",
"control",
"dispatcher",
"control",
"dispatcher",
")",
"{",
"if",
"(",
"this",
"control",
"dispatcher",
"!",
"=",
"control",
"dispatcher",
")",
"{",
"this",
"control",
"dispatcher",
"=",
"control",
"dispatcher",
";",
"update",
"navigation",
"(",
")",
";",
"}",
"}"
] |
[
"defines",
"that",
"data",
"is",
"partitioned",
"across",
"input",
"splits",
"on",
"the",
"fields",
"defined",
"by",
"field",
"positions",
"all",
"records",
"sharing",
"the",
"same",
"key",
"(",
"combination",
")",
"must",
"be",
"contained",
"in",
"a",
"single",
"input",
"split",
"<",
"b",
">",
"important",
":",
"providing",
"wrong",
"information",
"with",
"split",
"data",
"properties",
"can",
"cause",
"wrong",
"results",
"!",
"<",
"b",
">"
] | [
"public",
"split",
"data",
"properties",
"<",
"t",
">",
"splits",
"partitioned",
"by",
"(",
"int",
"partition",
"fields",
")",
"{",
"return",
"this",
"splits",
"partitioned",
"by",
"(",
"null",
",",
"partition",
"fields",
")",
";",
"}"
] |
[
"returns",
"the",
"<",
"a",
"href",
"=",
"\"",
"http",
":",
"mathworld",
"wolfram",
"com",
"correlation",
"coefficient",
"html",
"\"",
">",
"pearson",
"'",
"s",
"or",
"product",
"-",
"moment",
"correlation",
"coefficient",
"of",
"the",
"values",
"the",
"count",
"must",
"greater",
"than",
"one",
",",
"and",
"the",
"{",
"@",
"code",
"x",
"}",
"and",
"{",
"@",
"code",
"y",
"}",
"values",
"must",
"both",
"have",
"non",
"-",
"zero",
"population",
"variance",
"(",
"i",
"e",
"{",
"@",
"code",
"x",
"stats",
"(",
")",
"population",
"variance",
"(",
")",
">",
"0",
"0",
"&",
"&",
"y",
"stats",
"(",
")",
"population",
"variance",
"(",
")",
">",
"0",
"0",
"}",
")",
"the",
"result",
"is",
"not",
"guaranteed",
"to",
"be",
"exactly",
"+",
"-",
"1",
"even",
"when",
"the",
"data",
"are",
"perfectly",
"(",
"anti",
"-",
")",
"correlated",
",",
"due",
"to",
"numerical",
"errors",
"however",
",",
"it",
"is",
"guaranteed",
"to",
"be",
"in",
"the",
"inclusive",
"range",
"[",
"-",
"1",
",",
"+",
"1",
"]",
"<",
"h",
"3",
">",
"non",
"-",
"finite",
"values",
"<",
"h",
"3",
">",
"if",
"the",
"dataset",
"contains",
"any",
"non",
"-",
"finite",
"values",
"(",
"{",
"@",
"link",
"double",
"#",
"positive",
"infinity",
"}",
",",
"{",
"@",
"link",
"double",
"#",
"negative",
"infinity",
"}",
",",
"or",
"{",
"@",
"link",
"double",
"#",
"na",
"n",
"}",
")",
"then",
"the",
"result",
"is",
"{",
"@",
"link",
"double",
"#",
"na",
"n",
"}"
] | [
"public",
"final",
"double",
"pearsons",
"correlation",
"coefficient",
"(",
")",
"{",
"check",
"state",
"(",
"count",
"(",
")",
">",
"1",
")",
";",
"if",
"(",
"is",
"na",
"n",
"(",
"sum",
"of",
"products",
"of",
"deltas",
")",
")",
"{",
"return",
"na",
"n",
";",
"}",
"double",
"x",
"sum",
"of",
"squares",
"of",
"deltas",
"=",
"x",
"stats",
"sum",
"of",
"squares",
"of",
"deltas",
"(",
")",
";",
"double",
"y",
"sum",
"of",
"squares",
"of",
"deltas",
"=",
"y",
"stats",
"sum",
"of",
"squares",
"of",
"deltas",
"(",
")",
";",
"check",
"state",
"(",
"x",
"sum",
"of",
"squares",
"of",
"deltas",
">",
"0",
"0",
")",
";",
"check",
"state",
"(",
"y",
"sum",
"of",
"squares",
"of",
"deltas",
">",
"0",
"0",
")",
";",
"/",
"/",
"the",
"product",
"of",
"two",
"positive",
"numbers",
"can",
"be",
"zero",
"if",
"the",
"multiplication",
"underflowed",
"we",
"/",
"/",
"force",
"a",
"positive",
"value",
"by",
"effectively",
"rounding",
"up",
"to",
"min",
"value",
"double",
"product",
"of",
"sums",
"of",
"squares",
"of",
"deltas",
"=",
"ensure",
"positive",
"(",
"x",
"sum",
"of",
"squares",
"of",
"deltas",
"*",
"y",
"sum",
"of",
"squares",
"of",
"deltas",
")",
";",
"return",
"ensure",
"in",
"unit",
"range",
"(",
"sum",
"of",
"products",
"of",
"deltas",
"/",
"math",
"sqrt",
"(",
"product",
"of",
"sums",
"of",
"squares",
"of",
"deltas",
")",
")",
";",
"}"
] |
[
"sets",
"{",
"@",
"code",
"visitor",
"}",
"as",
"the",
"visitor",
"for",
"all",
"instructions"
] | [
"public",
"void",
"set",
"all",
"visitors",
"(",
"visitor",
"visitor",
")",
"{",
"fallback",
"visitor",
"=",
"visitor",
";",
"string",
"visitor",
"=",
"visitor",
";",
"type",
"visitor",
"=",
"visitor",
";",
"field",
"visitor",
"=",
"visitor",
";",
"method",
"visitor",
"=",
"visitor",
";",
"}"
] |
[
"add",
"a",
"sink",
"writer",
"node",
"to",
"the",
"stream",
"graph"
] | [
"private",
"int",
"add",
"writer",
"(",
"sink",
"transformation",
"<",
"input",
"t",
",",
"comm",
"t",
",",
"writer",
"state",
"t",
",",
"global",
"comm",
"t",
">",
"sink",
"transformation",
",",
"int",
"parallelism",
",",
"@",
"nullable",
"string",
"previous",
"sink",
"state",
"name",
",",
"context",
"context",
")",
"{",
"final",
"boolean",
"has",
"state",
"=",
"sink",
"transformation",
"get",
"sink",
"(",
")",
"get",
"writer",
"state",
"serializer",
"(",
")",
"is",
"present",
"(",
")",
";",
"check",
"state",
"(",
"sink",
"transformation",
"get",
"inputs",
"(",
")",
"size",
"(",
")",
"=",
"=",
"1",
")",
";",
"@",
"suppress",
"warnings",
"(",
"\"",
"unchecked",
"\"",
")",
"final",
"transformation",
"<",
"input",
"t",
">",
"input",
"=",
"(",
"transformation",
"<",
"input",
"t",
">",
")",
"sink",
"transformation",
"get",
"inputs",
"(",
")",
"get",
"(",
"0",
")",
";",
"final",
"type",
"information",
"<",
"input",
"t",
">",
"input",
"type",
"info",
"=",
"input",
"get",
"output",
"type",
"(",
")",
";",
"final",
"stream",
"operator",
"factory",
"<",
"comm",
"t",
">",
"writer",
"=",
"has",
"state",
"?",
"new",
"stateful",
"sink",
"writer",
"operator",
"factory",
"<",
">",
"(",
"sink",
"transformation",
"get",
"sink",
"(",
")",
",",
"previous",
"sink",
"state",
"name",
")",
":",
"new",
"stateless",
"sink",
"writer",
"operator",
"factory",
"<",
">",
"(",
"sink",
"transformation",
"get",
"sink",
"(",
")",
")",
";",
"final",
"string",
"prefix",
"=",
"\"",
"sink",
"writer",
":",
"\"",
";",
"final",
"chaining",
"strategy",
"chaining",
"strategy",
"=",
"sink",
"transformation",
"get",
"chaining",
"strategy",
"(",
")",
";",
"if",
"(",
"chaining",
"strategy",
"!",
"=",
"null",
")",
"{",
"writer",
"set",
"chaining",
"strategy",
"(",
"chaining",
"strategy",
")",
";",
"}",
"return",
"add",
"operator",
"to",
"stream",
"graph",
"(",
"writer",
",",
"context",
"get",
"stream",
"node",
"ids",
"(",
"input",
")",
",",
"input",
"type",
"info",
",",
"extract",
"committable",
"type",
"information",
"(",
"sink",
"transformation",
"get",
"sink",
"(",
")",
")",
",",
"string",
"format",
"(",
"\"",
"%",
"s",
"%",
"s",
"\"",
",",
"prefix",
",",
"sink",
"transformation",
"get",
"name",
"(",
")",
")",
",",
"sink",
"transformation",
"get",
"uid",
"(",
")",
",",
"parallelism",
",",
"sink",
"transformation",
"get",
"max",
"parallelism",
"(",
")",
",",
"sink",
"transformation",
",",
"context",
")",
";",
"}"
] |
[
"returns",
"the",
"size",
"of",
"the",
"physical",
"memory",
"in",
"bytes",
"on",
"free",
"b",
"s",
"d"
] | [
"private",
"static",
"long",
"get",
"size",
"of",
"physical",
"memory",
"for",
"free",
"b",
"s",
"d",
"(",
")",
"{",
"buffered",
"reader",
"bi",
"=",
"null",
";",
"try",
"{",
"process",
"proc",
"=",
"runtime",
"get",
"runtime",
"(",
")",
"exec",
"(",
"\"",
"sysctl",
"hw",
"physmem",
"\"",
")",
";",
"bi",
"=",
"new",
"buffered",
"reader",
"(",
"new",
"input",
"stream",
"reader",
"(",
"proc",
"get",
"input",
"stream",
"(",
")",
")",
")",
";",
"string",
"line",
";",
"while",
"(",
"(",
"line",
"=",
"bi",
"read",
"line",
"(",
")",
")",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"line",
"starts",
"with",
"(",
"\"",
"hw",
"physmem",
"\"",
")",
")",
"{",
"long",
"memsize",
"=",
"long",
"parse",
"long",
"(",
"line",
"split",
"(",
"\"",
":",
"\"",
")",
"[",
"1",
"]",
"trim",
"(",
")",
")",
";",
"bi",
"close",
"(",
")",
";",
"proc",
"destroy",
"(",
")",
";",
"return",
"memsize",
";",
"}",
"}",
"log",
"error",
"(",
"\"",
"cannot",
"determine",
"the",
"size",
"of",
"the",
"physical",
"memory",
"for",
"free",
"b",
"s",
"d",
"host",
"\"",
"+",
"\"",
"(",
"using",
"'",
"sysctl",
"hw",
"physmem",
"'",
")",
"\"",
")",
";",
"return",
"-",
"1",
";",
"}",
"catch",
"(",
"throwable",
"t",
")",
"{",
"log",
"error",
"(",
"\"",
"cannot",
"determine",
"the",
"size",
"of",
"the",
"physical",
"memory",
"for",
"free",
"b",
"s",
"d",
"host",
"\"",
"+",
"\"",
"(",
"using",
"'",
"sysctl",
"hw",
"physmem",
"'",
")",
"\"",
",",
"t",
")",
";",
"return",
"-",
"1",
";",
"}",
"finally",
"{",
"if",
"(",
"bi",
"!",
"=",
"null",
")",
"{",
"try",
"{",
"bi",
"close",
"(",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ignored",
")",
"{",
"}",
"}",
"}",
"}"
] |
[
"gets",
"a",
"{",
"@",
"link",
"field",
"permissions",
"}",
"instance",
"that",
"corresponds",
"to",
"the",
"granted",
"and",
"denied",
"parameters",
"the",
"instance",
"may",
"come",
"from",
"the",
"cache",
"or",
"if",
"it",
"gets",
"created",
",",
"the",
"instance",
"will",
"be",
"cached"
] | [
"public",
"field",
"permissions",
"get",
"field",
"permissions",
"(",
"field",
"permissions",
"definition",
"field",
"permissions",
"definition",
")",
"{",
"try",
"{",
"return",
"cache",
"compute",
"if",
"absent",
"(",
"field",
"permissions",
"definition",
",",
"(",
"key",
")",
"-",
">",
"new",
"field",
"permissions",
"(",
"key",
",",
"field",
"permissions",
"initialize",
"permitted",
"fields",
"automaton",
"(",
"key",
")",
")",
")",
";",
"}",
"catch",
"(",
"execution",
"exception",
"e",
")",
"{",
"throw",
"new",
"elasticsearch",
"exception",
"(",
"\"",
"unable",
"to",
"compute",
"field",
"permissions",
"\"",
",",
"e",
")",
";",
"}",
"}"
] |
[
"set",
"the",
"paths",
"to",
"be",
"used",
"as",
"the",
"user",
"plugin",
"path",
"property"
] | [
"public",
"static",
"void",
"set",
"plugin",
"paths",
"(",
"string",
"[",
"]",
"paths",
")",
"{",
"if",
"(",
"paths",
"=",
"=",
"null",
"|",
"|",
"paths",
"length",
"=",
"=",
"0",
")",
"{",
"properties",
"remove",
"(",
"user",
"plugin",
"path",
")",
";",
"return",
";",
"}",
"string",
"buffer",
"sb",
"=",
"new",
"string",
"buffer",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"paths",
"length",
";",
"i",
"+",
"+",
")",
"{",
"sb",
"append",
"(",
"paths",
"[",
"i",
"]",
")",
";",
"if",
"(",
"i",
"<",
"paths",
"length",
"-",
"1",
")",
"{",
"sb",
"append",
"(",
"file",
"path",
"separator",
")",
";",
"}",
"}",
"properties",
"set",
"property",
"(",
"user",
"plugin",
"path",
",",
"sb",
"to",
"string",
"(",
")",
")",
";",
"}"
] |
[
"get",
"the",
"inode",
"from",
"inode",
"map",
"based",
"on",
"its",
"inode",
"id"
] | [
"public",
"i",
"node",
"get",
"inode",
"(",
"long",
"id",
")",
"{",
"return",
"inode",
"map",
"get",
"(",
"id",
")",
";",
"}"
] |
[
"use",
"the",
"configured",
"{",
"@",
"link",
"reactive",
"adapter",
"registry",
"}",
"to",
"adapt",
"asynchronous",
"attributes",
"to",
"{",
"@",
"code",
"mono",
"<",
"t",
">",
"}",
"or",
"{",
"@",
"code",
"mono",
"<",
"list",
"<",
"t",
">",
">",
"}",
"and",
"then",
"wait",
"to",
"resolve",
"them",
"into",
"actual",
"values",
"when",
"the",
"returned",
"{",
"@",
"code",
"mono",
"<",
"void",
">",
"}",
"completes",
",",
"the",
"asynchronous",
"attributes",
"in",
"the",
"model",
"would",
"have",
"been",
"replaced",
"with",
"their",
"corresponding",
"resolved",
"values"
] | [
"protected",
"mono",
"<",
"void",
">",
"resolve",
"async",
"attributes",
"(",
"map",
"<",
"string",
",",
"object",
">",
"model",
")",
"{",
"return",
"mono",
"empty",
"(",
")",
";",
"}"
] |
[
"create",
"a",
"new",
"remote",
"invocation",
"object",
"for",
"the",
"given",
"aop",
"method",
"invocation",
"the",
"default",
"implementation",
"delegates",
"to",
"the",
"configured",
"{",
"@",
"link",
"#",
"set",
"remote",
"invocation",
"factory",
"remote",
"invocation",
"factory",
"}",
"this",
"can",
"be",
"overridden",
"in",
"subclasses",
"in",
"order",
"to",
"provide",
"custom",
"remote",
"invocation",
"subclasses",
",",
"containing",
"additional",
"invocation",
"parameters",
"(",
"e",
"g",
"user",
"credentials",
")",
"note",
"that",
"it",
"is",
"preferable",
"to",
"build",
"a",
"custom",
"remote",
"invocation",
"factory",
"as",
"a",
"reusable",
"strategy",
",",
"instead",
"of",
"overriding",
"this",
"method"
] | [
"protected",
"remote",
"invocation",
"create",
"remote",
"invocation",
"(",
"method",
"invocation",
"method",
"invocation",
")",
"{",
"return",
"get",
"remote",
"invocation",
"factory",
"(",
")",
"create",
"remote",
"invocation",
"(",
"method",
"invocation",
")",
";",
"}"
] |
[
"return",
"the",
"line",
"number",
"in",
"the",
"xml",
"resource",
"that",
"failed"
] | [
"public",
"int",
"get",
"line",
"number",
"(",
")",
"{",
"throwable",
"cause",
"=",
"get",
"cause",
"(",
")",
";",
"if",
"(",
"cause",
"instanceof",
"s",
"a",
"x",
"parse",
"exception",
")",
"{",
"return",
"(",
"(",
"s",
"a",
"x",
"parse",
"exception",
")",
"cause",
")",
"get",
"line",
"number",
"(",
")",
";",
"}",
"return",
"-",
"1",
";",
"}"
] |
[
"creates",
"a",
"snapshot",
"of",
"this",
"{",
"@",
"link",
"copy",
"on",
"write",
"state",
"map",
"}",
",",
"to",
"be",
"written",
"in",
"checkpointing",
"the",
"snapshot",
"integrity",
"is",
"protected",
"through",
"copy",
"-",
"on",
"-",
"write",
"from",
"the",
"{",
"@",
"link",
"copy",
"on",
"write",
"state",
"map",
"}",
"users",
"should",
"call",
"{",
"@",
"link",
"#",
"release",
"snapshot",
"(",
"state",
"map",
"snapshot",
")",
"}",
"after",
"using",
"the",
"returned",
"object"
] | [
"public",
"copy",
"on",
"write",
"state",
"map",
"snapshot",
"<",
"k",
",",
"n",
",",
"s",
">",
"state",
"snapshot",
"(",
")",
"{",
"return",
"new",
"copy",
"on",
"write",
"state",
"map",
"snapshot",
"<",
">",
"(",
"this",
")",
";",
"}"
] |
[
"returns",
"the",
"actual",
"position",
"in",
"pixels",
"of",
"the",
"marker",
"view",
"for",
"the",
"given",
"highlight",
"object"
] | [
"protected",
"float",
"[",
"]",
"get",
"marker",
"position",
"(",
"highlight",
"high",
")",
"{",
"return",
"new",
"float",
"[",
"]",
"{",
"high",
"get",
"draw",
"x",
"(",
")",
",",
"high",
"get",
"draw",
"y",
"(",
")",
"}",
";",
"}"
] |
[
"returns",
"true",
"if",
"the",
"map",
"view",
"contains",
"no",
"key",
"-",
"value",
"mappings",
",",
"otherwise",
"false"
] | [
"public",
"boolean",
"is",
"empty",
"(",
")",
"throws",
"exception",
"{",
"return",
"map",
"is",
"empty",
"(",
")",
";",
"}"
] |
[
"computes",
"counters",
"for",
"write"
] | [
"void",
"bytes",
"write",
"flow",
"control",
"(",
"long",
"write",
")",
"{",
"current",
"written",
"bytes",
"add",
"and",
"get",
"(",
"write",
")",
";",
"cumulative",
"written",
"bytes",
"add",
"and",
"get",
"(",
"write",
")",
";",
"}"
] |
[
"encode",
"\"",
"-",
"tu",
"<",
"n",
",",
"l",
",",
"a",
",",
"o",
">",
"-",
"\"",
"in",
"cases",
"where",
"it",
"is",
"pronounced",
"x",
"(",
"\"",
"sh",
"\"",
",",
"or",
"in",
"this",
"case",
",",
"\"",
"ch",
"\"",
")"
] | [
"boolean",
"encode",
"tun",
"tul",
"tua",
"tuo",
"(",
")",
"{",
"/",
"/",
"e",
"g",
"\"",
"fortune",
"\"",
",",
"\"",
"fortunate",
"\"",
"if",
"(",
"string",
"at",
"(",
"(",
"m",
"current",
"-",
"3",
")",
",",
"6",
",",
"\"",
"fortun",
"\"",
",",
"\"",
"\"",
")",
"/",
"/",
"e",
"g",
"\"",
"capitulate",
"\"",
"|",
"|",
"(",
"string",
"at",
"(",
"m",
"current",
",",
"3",
",",
"\"",
"tul",
"\"",
",",
"\"",
"\"",
")",
"&",
"&",
"(",
"is",
"vowel",
"(",
"m",
"current",
"-",
"1",
")",
"&",
"&",
"is",
"vowel",
"(",
"m",
"current",
"+",
"3",
")",
")",
")",
"/",
"/",
"e",
"g",
"\"",
"obituary",
"\"",
",",
"\"",
"barbituate",
"\"",
"|",
"|",
"string",
"at",
"(",
"(",
"m",
"current",
"-",
"2",
")",
",",
"5",
",",
"\"",
"bitua",
"\"",
",",
"\"",
"bitue",
"\"",
",",
"\"",
"\"",
")",
"/",
"/",
"e",
"g",
"\"",
"actual",
"\"",
"|",
"|",
"(",
"(",
"m",
"current",
">",
"1",
")",
"&",
"&",
"string",
"at",
"(",
"m",
"current",
",",
"3",
",",
"\"",
"tua",
"\"",
",",
"\"",
"tuo",
"\"",
",",
"\"",
"\"",
")",
")",
")",
"{",
"metaph",
"add",
"(",
"\"",
"x",
"\"",
",",
"\"",
"t",
"\"",
")",
";",
"m",
"current",
"+",
"+",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}"
] |
[
"retrieves",
"the",
"new",
"name",
"of",
"the",
"given",
"class"
] | [
"static",
"string",
"new",
"class",
"name",
"(",
"clazz",
"clazz",
")",
"{",
"object",
"visitor",
"info",
"=",
"clazz",
"get",
"visitor",
"info",
"(",
")",
";",
"return",
"visitor",
"info",
"instanceof",
"string",
"?",
"(",
"string",
")",
"visitor",
"info",
":",
"null",
";",
"}"
] |
[
"specify",
"the",
"build",
"step",
"that",
"want",
"to",
"run",
"the",
"command",
"to",
"enable",
"the",
"environment",
"filters"
] | [
"public",
"proc",
"starter",
"build",
"step",
"(",
"env",
"vars",
"filterable",
"builder",
"env",
"vars",
"filterable",
"builder",
")",
"{",
"this",
"env",
"vars",
"filterable",
"builder",
"=",
"env",
"vars",
"filterable",
"builder",
";",
"return",
"this",
";",
"}"
] |
[
"return",
"the",
"hex",
"string",
"of",
"file",
"'",
"s",
"md5",
"encryption"
] | [
"public",
"static",
"string",
"encrypt",
"m",
"d",
"5",
"file",
"2",
"string",
"(",
"final",
"string",
"file",
"path",
")",
"{",
"file",
"file",
"=",
"utils",
"bridge",
"is",
"space",
"(",
"file",
"path",
")",
"?",
"null",
":",
"new",
"file",
"(",
"file",
"path",
")",
";",
"return",
"encrypt",
"m",
"d",
"5",
"file",
"2",
"string",
"(",
"file",
")",
";",
"}"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"find",
"pet",
"by",
"id",
"returns",
"a",
"single",
"pet"
] | [
"public",
"pet",
"get",
"pet",
"by",
"id",
"(",
"long",
"pet",
"id",
")",
"throws",
"api",
"exception",
"{",
"api",
"response",
"<",
"pet",
">",
"local",
"var",
"resp",
"=",
"get",
"pet",
"by",
"id",
"with",
"http",
"info",
"(",
"pet",
"id",
")",
";",
"return",
"local",
"var",
"resp",
"get",
"data",
"(",
")",
";",
"}"
] |
[
"check",
"if",
"this",
"cached",
"observable",
"is",
"connected",
"to",
"its",
"source"
] | [
"/",
"*",
"public",
"*",
"/",
"boolean",
"is",
"connected",
"(",
")",
"{",
"return",
"once",
"get",
"(",
")",
";",
"}"
] |
[
"check",
"the",
"path",
",",
"ignoring",
"authentication",
"details",
"see",
"{",
"@",
"link",
"file",
"system",
"#",
"check",
"path",
"(",
"path",
")",
"}",
"for",
"the",
"operation",
"of",
"this",
"essentially",
"the",
"uri",
"is",
"canonicalized",
"if",
"the",
"schemas",
"match",
",",
"the",
"hosts",
"are",
"compared",
"if",
"there",
"is",
"a",
"mismatch",
"between",
"nullnon",
"-",
"null",
"host",
",",
"the",
"default",
"fs",
"values",
"are",
"used",
"to",
"patch",
"in",
"the",
"host",
"that",
"all",
"originates",
"in",
"the",
"core",
"fs",
";",
"the",
"sole",
"change",
"here",
"being",
"to",
"use",
"{",
"@",
"link",
"uri",
"#",
"get",
"host",
"(",
")",
"}",
"over",
"{",
"@",
"link",
"uri",
"#",
"get",
"authority",
"(",
")",
"}",
"some",
"of",
"that",
"code",
"looks",
"a",
"relic",
"of",
"the",
"code",
"anti",
"-",
"pattern",
"of",
"using",
"\"",
"hdfs",
":",
"file",
"txt",
"\"",
"to",
"define",
"the",
"path",
"without",
"declaring",
"the",
"hostname",
"it",
"'",
"s",
"retained",
"for",
"compatibility"
] | [
"public",
"static",
"void",
"check",
"path",
"(",
"configuration",
"conf",
",",
"uri",
"fs",
"uri",
",",
"path",
"path",
",",
"int",
"default",
"port",
")",
"{",
"uri",
"path",
"uri",
"=",
"path",
"to",
"uri",
"(",
")",
";",
"string",
"that",
"scheme",
"=",
"path",
"uri",
"get",
"scheme",
"(",
")",
";",
"if",
"(",
"that",
"scheme",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"fs",
"is",
"relative",
"return",
";",
"}",
"uri",
"this",
"uri",
"=",
"canonicalize",
"uri",
"(",
"fs",
"uri",
",",
"default",
"port",
")",
";",
"string",
"this",
"scheme",
"=",
"this",
"uri",
"get",
"scheme",
"(",
")",
";",
"/",
"/",
"hostname",
"and",
"scheme",
"are",
"not",
"case",
"sensitive",
"in",
"these",
"checks",
"if",
"(",
"equals",
"ignore",
"case",
"(",
"this",
"scheme",
",",
"that",
"scheme",
")",
")",
"{",
"/",
"/",
"schemes",
"match",
"string",
"this",
"host",
"=",
"this",
"uri",
"get",
"host",
"(",
")",
";",
"string",
"that",
"host",
"=",
"path",
"uri",
"get",
"host",
"(",
")",
";",
"if",
"(",
"that",
"host",
"=",
"=",
"null",
"&",
"&",
"/",
"/",
"path",
"'",
"s",
"host",
"is",
"null",
"this",
"host",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"fs",
"has",
"a",
"host",
"uri",
"default",
"uri",
"=",
"file",
"system",
"get",
"default",
"uri",
"(",
"conf",
")",
";",
"if",
"(",
"equals",
"ignore",
"case",
"(",
"this",
"scheme",
",",
"default",
"uri",
"get",
"scheme",
"(",
")",
")",
")",
"{",
"path",
"uri",
"=",
"default",
"uri",
";",
"/",
"/",
"schemes",
"match",
",",
"so",
"use",
"this",
"uri",
"instead",
"}",
"else",
"{",
"path",
"uri",
"=",
"null",
";",
"/",
"/",
"can",
"'",
"t",
"determine",
"auth",
"of",
"the",
"path",
"}",
"}",
"if",
"(",
"path",
"uri",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"canonicalize",
"uri",
"before",
"comparing",
"with",
"this",
"fs",
"path",
"uri",
"=",
"canonicalize",
"uri",
"(",
"path",
"uri",
",",
"default",
"port",
")",
";",
"that",
"host",
"=",
"path",
"uri",
"get",
"host",
"(",
")",
";",
"if",
"(",
"this",
"host",
"=",
"=",
"that",
"host",
"|",
"|",
"/",
"/",
"hosts",
"match",
"(",
"this",
"host",
"!",
"=",
"null",
"&",
"&",
"equals",
"ignore",
"case",
"(",
"this",
"host",
",",
"that",
"host",
")",
")",
")",
"{",
"return",
";",
"}",
"}",
"}",
"/",
"/",
"make",
"sure",
"the",
"exception",
"strips",
"out",
"any",
"auth",
"details",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"wrong",
"fs",
"\"",
"+",
"s",
"3x",
"login",
"helper",
"to",
"string",
"(",
"path",
"uri",
")",
"+",
"\"",
"-",
"expected",
"\"",
"+",
"fs",
"uri",
")",
";",
"}"
] |
[
"checks",
"that",
"the",
"{",
"@",
"link",
"raw",
"value",
"data",
"}",
"is",
"equivalent",
"to",
"the",
"expected",
"one",
"the",
"serializer",
"will",
"be",
"used",
"to",
"ensure",
"both",
"objects",
"are",
"materialized",
"into",
"the",
"binary",
"form"
] | [
"public",
"static",
"raw",
"value",
"data",
"asserter",
"equivalent",
"(",
"raw",
"value",
"data",
"<",
"?",
">",
"expected",
",",
"raw",
"value",
"data",
"serializer",
"<",
"?",
">",
"serializer",
")",
"{",
"binary",
"raw",
"value",
"data",
"binary",
"expected",
"=",
"(",
"(",
"binary",
"raw",
"value",
"data",
")",
"expected",
")",
";",
"binary",
"expected",
"ensure",
"materialized",
"(",
"serializer",
"get",
"inner",
"serializer",
"(",
")",
")",
";",
"return",
"new",
"raw",
"value",
"data",
"asserter",
"(",
"binary",
"expected",
",",
"serializer",
")",
";",
"}",
"@",
"override",
"@",
"suppress",
"warnings",
"(",
"{",
"\"",
"unchecked",
"\"",
",",
"\"",
"rawtypes",
"\"",
"}"
] |
[
"parameter",
"kind",
"(",
"i",
"n",
"o",
"u",
"tetc",
")"
] | [
"d",
"b",
"s",
"procedure",
"parameter",
"kind",
"get",
"parameter",
"kind",
"(",
")",
";"
] |
[
"the",
"indices",
"the",
"mappings",
"will",
"be",
"put"
] | [
"public",
"string",
"[",
"]",
"indices",
"(",
")",
"{",
"return",
"indices",
";",
"}"
] |
[
"don",
"'",
"t",
"explode",
"when",
"resending",
"an",
"empty",
"post",
"https",
":",
"github",
"comsquareokhttpissues",
"1",
"1",
"3",
"1"
] | [
"@",
"test",
"public",
"void",
"post",
"empty",
"body",
"retransmitted",
"after",
"authorization",
"fail",
"(",
")",
"throws",
"exception",
"{",
"post",
"body",
"retransmitted",
"after",
"authorization",
"fail",
"(",
"\"",
"\"",
")",
";",
"}"
] |
[
"10",
":",
"call",
"30",
"-",
"-",
"-",
"-",
"+",
"(",
"start",
")",
"12",
":",
"breq",
"20",
"-",
"-",
"+",
"|",
"14",
":",
"ret",
"|",
"|",
"+",
"-",
">",
"16",
":",
"ret",
"|",
"|",
"(",
"should",
"not",
"disassemble",
")",
"|",
"^",
"^",
"restrict",
"^",
"^",
"|",
"|",
"|",
"|",
"|",
"+",
"-",
"-",
"20",
":",
"breq",
"16",
"<",
"-",
"+",
"|",
"(",
"should",
"not",
"disassemble",
")",
"22",
":",
"ret",
"|",
"(",
"should",
"not",
"disassemble",
")",
"|",
"30",
":",
"ret",
"<",
"-",
"-",
"-",
"+",
"(",
"should",
"not",
"disassemble",
")",
"test",
"restricted",
"disassembly"
] | [
"public",
"void",
"test",
"disassembler",
"restricted",
"(",
")",
"throws",
"exception",
"{",
"program",
"builder",
"add",
"bytes",
"call",
"(",
"10",
",",
"30",
")",
";",
"program",
"builder",
"add",
"bytes",
"branch",
"conditional",
"(",
"12",
",",
"20",
")",
";",
"program",
"builder",
"add",
"bytes",
"return",
"(",
"14",
")",
";",
"program",
"builder",
"add",
"bytes",
"return",
"(",
"16",
")",
";",
"program",
"builder",
"add",
"bytes",
"branch",
"conditional",
"(",
"20",
",",
"16",
")",
";",
"program",
"builder",
"add",
"bytes",
"return",
"(",
"22",
")",
";",
"program",
"builder",
"add",
"bytes",
"return",
"(",
"30",
")",
";",
"address",
"set",
"restrict",
"set",
"=",
"addrset",
"(",
"range",
"(",
"0",
",",
"19",
")",
")",
";",
"address",
"set",
"view",
"dis",
"addrs",
"=",
"disassembler",
"disassemble",
"(",
"addr",
"(",
"10",
")",
",",
"restrict",
"set",
")",
";",
"assert",
"equals",
"(",
"addrset",
"(",
"range",
"(",
"10",
",",
"15",
")",
")",
",",
"dis",
"addrs",
")",
";",
"verify",
"instruction",
"presence",
"(",
"collection",
"utils",
"as",
"set",
"(",
"addr",
"(",
"16",
")",
",",
"addr",
"(",
"20",
")",
",",
"addr",
"(",
"22",
")",
",",
"addr",
"(",
"30",
")",
")",
")",
";",
"verify",
"no",
"bookmarks",
"(",
")",
";",
"}"
] |
[
"returns",
"the",
"timestamp",
"when",
"the",
"checkpoint",
"was",
"triggered"
] | [
"public",
"long",
"get",
"trigger",
"timestamp",
"(",
")",
"{",
"return",
"trigger",
"timestamp",
";",
"}"
] |
[
"copies",
"a",
"basic",
"block",
",",
"mapping",
"its",
"successors",
"along",
"the",
"way"
] | [
"private",
"void",
"copy",
"block",
"(",
"int",
"orig",
"label",
",",
"int",
"new",
"label",
")",
"{",
"basic",
"block",
"orig",
"block",
"=",
"label",
"to",
"block",
"(",
"orig",
"label",
")",
";",
"final",
"int",
"list",
"orig",
"successors",
"=",
"orig",
"block",
"get",
"successors",
"(",
")",
";",
"int",
"list",
"successors",
";",
"int",
"primary",
"successor",
"=",
"-",
"1",
";",
"subroutine",
"subroutine",
";",
"if",
"(",
"is",
"subroutine",
"caller",
"(",
"orig",
"block",
")",
")",
"{",
"/",
"*",
"*",
"a",
"subroutine",
"call",
"inside",
"a",
"subroutine",
"call",
"*",
"set",
"up",
"so",
"we",
"can",
"recurse",
"the",
"caller",
"block",
"should",
"have",
"*",
"it",
"'",
"s",
"first",
"successor",
"be",
"a",
"copied",
"block",
"that",
"will",
"be",
"*",
"the",
"subroutine",
"'",
"s",
"return",
"point",
"it",
"'",
"s",
"second",
"successor",
"will",
"*",
"be",
"copied",
"when",
"we",
"recurse",
",",
"and",
"remains",
"as",
"the",
"original",
"*",
"label",
"of",
"the",
"start",
"of",
"the",
"inner",
"subroutine",
"*",
"/",
"successors",
"=",
"int",
"list",
"make",
"immutable",
"(",
"map",
"or",
"allocate",
"label",
"(",
"orig",
"successors",
"get",
"(",
"0",
")",
")",
",",
"orig",
"successors",
"get",
"(",
"1",
")",
")",
";",
"/",
"/",
"primary",
"successor",
"will",
"be",
"set",
"when",
"this",
"block",
"is",
"replaced",
"}",
"else",
"if",
"(",
"null",
"!",
"=",
"(",
"subroutine",
"=",
"subroutine",
"from",
"ret",
"block",
"(",
"orig",
"label",
")",
")",
")",
"{",
"/",
"*",
"*",
"this",
"is",
"a",
"ret",
"block",
"-",
"-",
"its",
"successor",
"*",
"should",
"be",
"subroutine",
"successor",
"*",
"/",
"/",
"/",
"sanity",
"check",
"if",
"(",
"subroutine",
"start",
"block",
"!",
"=",
"subroutine",
"start",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"ret",
"instruction",
"returns",
"to",
"label",
"\"",
"+",
"hex",
"u",
"2",
"(",
"subroutine",
"start",
"block",
")",
"+",
"\"",
"expected",
":",
"\"",
"+",
"hex",
"u",
"2",
"(",
"subroutine",
"start",
")",
")",
";",
"}",
"successors",
"=",
"int",
"list",
"make",
"immutable",
"(",
"subroutine",
"successor",
")",
";",
"primary",
"successor",
"=",
"subroutine",
"successor",
";",
"}",
"else",
"{",
"/",
"/",
"map",
"all",
"the",
"successor",
"labels",
"int",
"orig",
"primary",
"=",
"orig",
"block",
"get",
"primary",
"successor",
"(",
")",
";",
"int",
"sz",
"=",
"orig",
"successors",
"size",
"(",
")",
";",
"successors",
"=",
"new",
"int",
"list",
"(",
"sz",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"sz",
";",
"i",
"+",
"+",
")",
"{",
"int",
"orig",
"succ",
"label",
"=",
"orig",
"successors",
"get",
"(",
"i",
")",
";",
"int",
"new",
"succ",
"label",
"=",
"map",
"or",
"allocate",
"label",
"(",
"orig",
"succ",
"label",
")",
";",
"successors",
"add",
"(",
"new",
"succ",
"label",
")",
";",
"if",
"(",
"orig",
"primary",
"=",
"=",
"orig",
"succ",
"label",
")",
"{",
"primary",
"successor",
"=",
"new",
"succ",
"label",
";",
"}",
"}",
"successors",
"set",
"immutable",
"(",
")",
";",
"}",
"add",
"block",
"(",
"new",
"basic",
"block",
"(",
"new",
"label",
",",
"filter",
"move",
"return",
"address",
"insns",
"(",
"orig",
"block",
"get",
"insns",
"(",
")",
")",
",",
"successors",
",",
"primary",
"successor",
")",
",",
"label",
"to",
"subroutines",
"get",
"(",
"new",
"label",
")",
")",
";",
"}"
] |
[
"check",
"the",
"status",
"of",
"a",
"filedir"
] | [
"void",
"check",
"status",
"(",
"file",
"dir",
")",
"throws",
"disk",
"error",
"exception",
";"
] |
[
"if",
"type",
"is",
"all",
"returns",
"metrics",
"for",
"all",
"packages",
"loaded"
] | [
"collection",
"<",
"package",
"metrics",
">",
"get",
"package",
"metrics",
"(",
")",
";"
] |
[
"validates",
"and",
"extract",
"the",
"single",
"field",
"type",
"from",
"the",
"given",
"physical",
"row",
"schema"
] | [
"private",
"static",
"logical",
"type",
"validate",
"and",
"extract",
"single",
"field",
"(",
"row",
"type",
"physical",
"row",
"type",
")",
"{",
"if",
"(",
"physical",
"row",
"type",
"get",
"field",
"count",
"(",
")",
"!",
"=",
"1",
")",
"{",
"string",
"schema",
"string",
"=",
"physical",
"row",
"type",
"get",
"fields",
"(",
")",
"stream",
"(",
")",
"map",
"(",
"row",
"type",
"row",
"field",
":",
":",
"as",
"summary",
"string",
")",
"collect",
"(",
"collectors",
"joining",
"(",
"\"",
",",
"\"",
")",
")",
";",
"throw",
"new",
"validation",
"exception",
"(",
"string",
"format",
"(",
"\"",
"the",
"'",
"raw",
"'",
"format",
"only",
"supports",
"single",
"physical",
"column",
"\"",
"+",
"\"",
"however",
"the",
"defined",
"schema",
"contains",
"multiple",
"physical",
"columns",
":",
"[",
"%",
"s",
"]",
"\"",
",",
"schema",
"string",
")",
")",
";",
"}",
"logical",
"type",
"field",
"type",
"=",
"physical",
"row",
"type",
"get",
"children",
"(",
")",
"get",
"(",
"0",
")",
";",
"check",
"field",
"type",
"(",
"field",
"type",
")",
";",
"return",
"field",
"type",
";",
"}"
] |
[
"get",
"the",
"s3a",
"fs",
"of",
"a",
"path"
] | [
"public",
"static",
"s",
"3",
"a",
"file",
"system",
"get",
"s",
"3",
"a",
"file",
"system",
"(",
"path",
"path",
",",
"configuration",
"conf",
",",
"boolean",
"magic",
"commit",
"required",
")",
"throws",
"path",
"commit",
"exception",
",",
"i",
"o",
"exception",
"{",
"s",
"3",
"a",
"file",
"system",
"s",
"3",
"a",
"f",
"s",
"=",
"verify",
"is",
"s",
"3",
"a",
"f",
"s",
"(",
"path",
"get",
"file",
"system",
"(",
"conf",
")",
",",
"path",
")",
";",
"if",
"(",
"magic",
"commit",
"required",
")",
"{",
"verify",
"is",
"magic",
"commit",
"f",
"s",
"(",
"s",
"3",
"a",
"f",
"s",
")",
";",
"}",
"return",
"s",
"3",
"a",
"f",
"s",
";",
"}"
] |
[
"returns",
"the",
"snapshotted",
"checkpoint",
"history"
] | [
"public",
"checkpoint",
"stats",
"history",
"get",
"history",
"(",
")",
"{",
"return",
"history",
";",
"}"
] |
[
"get",
"the",
"string",
"distance",
"implementation",
"setting"
] | [
"public",
"string",
"distance",
"impl",
"string",
"distance",
"(",
")",
"{",
"return",
"string",
"distance",
";",
"}"
] |
[
"we",
"cannot",
"simply",
"use",
"fuzzy",
"query",
"directly",
"since",
"we",
"use",
"the",
"encoded",
"terms",
"from",
"the",
"dictionary",
",",
"but",
"the",
"automaton",
"in",
"the",
"query",
"will",
"assume",
"unencoded",
"terms",
"we",
"are",
"running",
"through",
"all",
"terms",
",",
"decode",
"them",
"and",
"then",
"run",
"them",
"through",
"the",
"automaton",
"manually",
"instead",
"this",
"is",
"not",
"as",
"efficient",
"as",
"intersecting",
"the",
"original",
"terms",
"with",
"the",
"compiled",
"automaton",
",",
"but",
"we",
"expect",
"the",
"number",
"of",
"distinct",
"version",
"terms",
"indexed",
"into",
"this",
"field",
"to",
"be",
"low",
"enough",
"and",
"the",
"use",
"of",
"\"",
"fuzzy",
"\"",
"queries",
"on",
"this",
"field",
"rare",
"enough",
"to",
"brute",
"-",
"force",
"this"
] | [
"public",
"query",
"fuzzy",
"query",
"(",
"object",
"value",
",",
"fuzziness",
"fuzziness",
",",
"int",
"prefix",
"length",
",",
"int",
"max",
"expansions",
",",
"boolean",
"transpositions",
",",
"query",
"shard",
"context",
"context",
")",
"{",
"if",
"(",
"context",
"allow",
"expensive",
"queries",
"(",
")",
"=",
"=",
"false",
")",
"{",
"throw",
"new",
"elasticsearch",
"exception",
"(",
"\"",
"[",
"fuzzy",
"]",
"queries",
"cannot",
"be",
"executed",
"when",
"'",
"\"",
"+",
"allow",
"expensive",
"queries",
"get",
"key",
"(",
")",
"+",
"\"",
"'",
"is",
"set",
"to",
"false",
"\"",
")",
";",
"}",
"return",
"new",
"fuzzy",
"query",
"(",
"new",
"term",
"(",
"name",
"(",
")",
",",
"(",
"bytes",
"ref",
")",
"value",
")",
",",
"fuzziness",
"as",
"distance",
"(",
"bytes",
"refs",
"to",
"string",
"(",
"value",
")",
")",
",",
"prefix",
"length",
",",
"max",
"expansions",
",",
"transpositions",
")",
"{",
"@",
"override",
"protected",
"terms",
"enum",
"get",
"terms",
"enum",
"(",
"terms",
"terms",
",",
"attribute",
"source",
"atts",
")",
"throws",
"i",
"o",
"exception",
"{",
"byte",
"run",
"automaton",
"run",
"automaton",
"=",
"get",
"automata",
"(",
")",
"run",
"automaton",
";",
"return",
"new",
"filtered",
"terms",
"enum",
"(",
"terms",
"iterator",
"(",
")",
",",
"false",
")",
"{",
"@",
"override",
"protected",
"accept",
"status",
"accept",
"(",
"bytes",
"ref",
"term",
")",
"throws",
"i",
"o",
"exception",
"{",
"byte",
"[",
"]",
"decoded",
"=",
"version",
"encoder",
"decode",
"version",
"(",
"term",
")",
"get",
"bytes",
"(",
"standard",
"charsets",
"utf",
"8",
")",
";",
"boolean",
"accepted",
"=",
"run",
"automaton",
"run",
"(",
"decoded",
",",
"0",
",",
"decoded",
"length",
")",
";",
"if",
"(",
"accepted",
")",
"{",
"return",
"accept",
"status",
"yes",
";",
"}",
"return",
"accept",
"status",
"no",
";",
"}",
"}",
";",
"}",
"}",
";",
"}"
] |
[
"special",
"version",
"of",
"remove",
"for",
"entry",
"set"
] | [
"int",
"entry",
"<",
"value",
">",
"remove",
"mapping",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"!",
"(",
"o",
"instanceof",
"int",
"entry",
")",
")",
"return",
"null",
";",
"int",
"entry",
"<",
"value",
">",
"entry",
"=",
"(",
"int",
"entry",
"<",
"value",
">",
")",
"o",
";",
"int",
"hash",
"=",
"hash",
"(",
"entry",
"key",
")",
";",
"int",
"i",
"=",
"index",
"for",
"(",
"hash",
",",
"table",
"length",
")",
";",
"int",
"entry",
"<",
"value",
">",
"prev",
"=",
"table",
"[",
"i",
"]",
";",
"int",
"entry",
"<",
"value",
">",
"e",
"=",
"prev",
";",
"while",
"(",
"e",
"!",
"=",
"null",
")",
"{",
"int",
"entry",
"<",
"value",
">",
"next",
"=",
"e",
"next",
";",
"if",
"(",
"e",
"hash",
"=",
"=",
"hash",
"&",
"&",
"e",
"equals",
"(",
"entry",
")",
")",
"{",
"mod",
"count",
"+",
"+",
";",
"size",
"-",
"-",
";",
"if",
"(",
"prev",
"=",
"=",
"e",
")",
"table",
"[",
"i",
"]",
"=",
"next",
";",
"else",
"prev",
"next",
"=",
"next",
";",
"return",
"e",
";",
"}",
"prev",
"=",
"e",
";",
"e",
"=",
"next",
";",
"}",
"return",
"e",
";",
"}"
] |
[
"these",
"two",
"username",
"produce",
"the",
"same",
"hashcode",
"per",
"the",
"semantics",
"put",
"out",
"by",
"{",
"@",
"link",
"string",
"#",
"hash",
"code",
"(",
")",
"}",
"the",
"cache",
"must",
"be",
"able",
"to",
"produce",
"two",
"different",
"results",
"for",
"each",
"user",
"while",
"also",
"maintaining",
"a",
"unique",
"cache",
"key",
"for",
"each"
] | [
"public",
"void",
"verify",
"operation",
"(",
")",
"{",
"val",
"p",
"1",
"=",
"caching",
"attribute",
"repository",
"get",
"person",
"(",
"\"",
"tensada",
"\"",
")",
";",
"assert",
"equals",
"(",
"\"",
"tensada",
"\"",
",",
"p",
"1",
"get",
"name",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"tens",
"\"",
",",
"p",
"1",
"get",
"attribute",
"value",
"(",
"\"",
"old",
"name",
"\"",
")",
")",
";",
"val",
"p",
"2",
"=",
"caching",
"attribute",
"repository",
"get",
"person",
"(",
"\"",
"friabili",
"\"",
")",
";",
"assert",
"equals",
"(",
"\"",
"friabili",
"\"",
",",
"p",
"2",
"get",
"name",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"fri",
"\"",
",",
"p",
"2",
"get",
"attribute",
"value",
"(",
"\"",
"old",
"name",
"\"",
")",
")",
";",
"}"
] |
[
"sets",
"directories",
"where",
"data",
"binding",
"reads",
"its",
"input",
"and",
"also",
"writes",
"its",
"output"
] | [
"public",
"data",
"binding",
"processor",
"args",
"builder",
"metadata",
"output",
"dir",
"(",
"string",
"metadata",
"output",
"dir",
")",
"{",
"if",
"(",
"use",
"updated",
"args",
")",
"{",
"flags",
"add",
"(",
"create",
"processor",
"flag",
"(",
"\"",
"dependency",
"artifacts",
"dir",
"\"",
",",
"metadata",
"output",
"dir",
"+",
"\"",
"/",
"\"",
"+",
"data",
"binding",
"dep",
"metadata",
"input",
"dir",
")",
")",
";",
"flags",
"add",
"(",
"create",
"processor",
"flag",
"(",
"\"",
"aar",
"out",
"dir",
"\"",
",",
"metadata",
"output",
"dir",
"+",
"\"",
"/",
"\"",
"+",
"data",
"binding",
"metadata",
"output",
"dir",
")",
")",
";",
"}",
"else",
"{",
"flags",
"add",
"(",
"create",
"processor",
"flag",
"(",
"\"",
"binding",
"build",
"folder",
"\"",
",",
"metadata",
"output",
"dir",
")",
")",
";",
"flags",
"add",
"(",
"create",
"processor",
"flag",
"(",
"\"",
"generational",
"file",
"out",
"dir",
"\"",
",",
"metadata",
"output",
"dir",
")",
")",
";",
"}",
"return",
"this",
";",
"}"
] |
[
"this",
"operation",
"is",
"not",
"supported"
] | [
"public",
"list",
"<",
"k",
">",
"sub",
"list",
"(",
"int",
"from",
"index",
",",
"int",
"to",
"index",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
")",
";",
"}"
] |
[
"gets",
"the",
"dwarf",
"encoding",
"used",
"for",
"the",
"call",
"site",
"table"
] | [
"public",
"int",
"get",
"call",
"site",
"table",
"encoding",
"(",
")",
"{",
"return",
"call",
"site",
"table",
"encoding",
";",
"}"
] |
[
"returns",
"a",
"read",
"-",
"only",
"buffer",
"that",
"shares",
"its",
"content",
"with",
"this",
"buffer",
"the",
"returned",
"buffer",
"is",
"guaranteed",
"to",
"be",
"a",
"new",
"instance",
",",
"even",
"if",
"this",
"buffer",
"is",
"read",
"-",
"only",
"itself",
"the",
"new",
"buffer",
"'",
"s",
"position",
",",
"limit",
",",
"capacity",
"and",
"mark",
"are",
"the",
"same",
"as",
"this",
"buffer",
"'",
"s",
"the",
"new",
"buffer",
"shares",
"its",
"content",
"with",
"this",
"buffer",
",",
"which",
"means",
"this",
"buffer",
"'",
"s",
"change",
"of",
"content",
"will",
"be",
"visible",
"to",
"the",
"new",
"buffer",
"the",
"two",
"buffer",
"'",
"s",
"position",
",",
"limit",
"and",
"mark",
"are",
"independent"
] | [
"public",
"abstract",
"short",
"buffer",
"as",
"read",
"only",
"buffer",
"(",
")",
";"
] |
[
"prepend",
"a",
"prefix",
"only",
"when",
"there",
"'",
"s",
"the",
"specified",
"body"
] | [
"public",
"string",
"prepend",
"(",
"string",
"prefix",
",",
"string",
"body",
")",
"{",
"if",
"(",
"body",
"!",
"=",
"null",
"&",
"&",
"body",
"length",
"(",
")",
">",
"0",
")",
"return",
"prefix",
"+",
"body",
";",
"return",
"body",
";",
"}"
] |
[
"return",
"the",
"expected",
"result",
"size"
] | [
"public",
"int",
"get",
"expected",
"size",
"(",
")",
"{",
"return",
"this",
"expected",
"size",
";",
"}"
] |
[
"swap",
"the",
"item",
"of",
"list"
] | [
"public",
"void",
"swap",
"positions",
"(",
"list",
"<",
"?",
">",
"list",
",",
"int",
"from",
",",
"int",
"to",
")",
"{",
"if",
"(",
"has",
"header",
"view",
"(",
")",
")",
"{",
"from",
"-",
"-",
";",
"to",
"-",
"-",
";",
"}",
"if",
"(",
"enable",
"load",
"more",
"(",
")",
"&",
"&",
"to",
"=",
"=",
"get",
"item",
"count",
"(",
")",
"-",
"1",
")",
"return",
";",
"if",
"(",
"has",
"header",
"view",
"(",
")",
"&",
"&",
"to",
"=",
"=",
"0",
")",
"return",
";",
"if",
"(",
"has",
"header",
"view",
"(",
")",
"&",
"&",
"from",
"=",
"=",
"0",
")",
"return",
";",
"if",
"(",
"enable",
"load",
"more",
"(",
")",
"&",
"&",
"from",
"=",
"=",
"get",
"item",
"count",
"(",
")",
"-",
"1",
")",
"return",
";",
"collections",
"swap",
"(",
"list",
",",
"from",
",",
"to",
")",
";",
"}"
] |
[
"just",
"hit",
"a",
"'",
":",
"'",
"and",
"want",
"to",
"jump",
"over",
"the",
"regex",
"specification",
"for",
"this",
"variable",
"pos",
"will",
"be",
"pointing",
"at",
"the",
"'",
":",
"'",
",",
"we",
"want",
"to",
"skip",
"until",
"the",
"}",
"nested",
"{",
"}",
"pairs",
"don",
"'",
"t",
"have",
"to",
"be",
"escaped",
":",
"<",
"tt",
">",
"abc",
"{",
"var",
":",
"x",
"{",
"1",
",",
"2",
"}",
"}",
"def",
"<",
"tt",
">",
"an",
"escaped",
"}",
"will",
"not",
"be",
"treated",
"as",
"the",
"end",
"of",
"the",
"regex",
":",
"<",
"tt",
">",
"abc",
"{",
"var",
":",
"x",
"\\",
"\\",
"{",
"y",
":",
"}",
"def",
"<",
"tt",
">",
"a",
"separator",
"that",
"should",
"not",
"indicate",
"the",
"end",
"of",
"the",
"regex",
"can",
"be",
"escaped",
":"
] | [
"private",
"void",
"skip",
"capture",
"regex",
"(",
")",
"{",
"this",
"pos",
"+",
"+",
";",
"int",
"regex",
"start",
"=",
"this",
"pos",
";",
"int",
"curly",
"bracket",
"depth",
"=",
"0",
";",
"/",
"/",
"how",
"deep",
"in",
"nested",
"{",
"}",
"pairs",
"boolean",
"previous",
"backslash",
"=",
"false",
";",
"while",
"(",
"this",
"pos",
"<",
"this",
"path",
"pattern",
"length",
")",
"{",
"char",
"ch",
"=",
"this",
"path",
"pattern",
"data",
"[",
"this",
"pos",
"]",
";",
"if",
"(",
"ch",
"=",
"=",
"'",
"\\",
"\\",
"'",
"&",
"&",
"!",
"previous",
"backslash",
")",
"{",
"this",
"pos",
"+",
"+",
";",
"previous",
"backslash",
"=",
"true",
";",
"continue",
";",
"}",
"if",
"(",
"ch",
"=",
"=",
"'",
"{",
"'",
"&",
"&",
"!",
"previous",
"backslash",
")",
"{",
"curly",
"bracket",
"depth",
"+",
"+",
";",
"}",
"else",
"if",
"(",
"ch",
"=",
"=",
"'",
"}",
"'",
"&",
"&",
"!",
"previous",
"backslash",
")",
"{",
"if",
"(",
"curly",
"bracket",
"depth",
"=",
"=",
"0",
")",
"{",
"if",
"(",
"regex",
"start",
"=",
"=",
"this",
"pos",
")",
"{",
"throw",
"new",
"pattern",
"parse",
"exception",
"(",
"regex",
"start",
",",
"this",
"path",
"pattern",
"data",
",",
"pattern",
"message",
"missing",
"regex",
"constraint",
")",
";",
"}",
"return",
";",
"}",
"curly",
"bracket",
"depth",
"-",
"-",
";",
"}",
"if",
"(",
"ch",
"=",
"=",
"this",
"parser",
"get",
"path",
"options",
"(",
")",
"separator",
"(",
")",
"&",
"&",
"!",
"previous",
"backslash",
")",
"{",
"throw",
"new",
"pattern",
"parse",
"exception",
"(",
"this",
"pos",
",",
"this",
"path",
"pattern",
"data",
",",
"pattern",
"message",
"missing",
"close",
"capture",
")",
";",
"}",
"this",
"pos",
"+",
"+",
";",
"previous",
"backslash",
"=",
"false",
";",
"}",
"throw",
"new",
"pattern",
"parse",
"exception",
"(",
"this",
"pos",
"-",
"1",
",",
"this",
"path",
"pattern",
"data",
",",
"pattern",
"message",
"missing",
"close",
"capture",
")",
";",
"}"
] |
[
"returns",
"the",
"weight",
"of",
"this",
"entry",
"from",
"the",
"policy",
"'",
"s",
"perspective"
] | [
"public",
"int",
"get",
"policy",
"weight",
"(",
")",
"{",
"return",
"1",
";",
"}"
] |
[
"returns",
"true",
"iff",
"this",
"path",
"denotes",
"an",
"existing",
"file",
"of",
"any",
"kind",
"follows",
"symbolic",
"links"
] | [
"public",
"boolean",
"exists",
"(",
")",
"{",
"return",
"file",
"system",
"exists",
"(",
"this",
",",
"true",
")",
";",
"}"
] |
[
"returns",
"the",
"managed",
"keyed",
"state",
"from",
"the",
"job",
"manager",
",",
"which",
"represents",
"the",
"ground",
"truth",
"about",
"what",
"this",
"state",
"should",
"represent",
"this",
"is",
"the",
"alternative",
"with",
"lowest",
"priority"
] | [
"public",
"state",
"object",
"collection",
"<",
"keyed",
"state",
"handle",
">",
"get",
"job",
"manager",
"managed",
"keyed",
"state",
"(",
")",
"{",
"return",
"last",
"element",
"(",
"prioritized",
"managed",
"keyed",
"state",
")",
";",
"}"
] |
[
"sets",
"bookmark",
"conflicts",
"to",
"always",
"be",
"overwritten"
] | [
"public",
"void",
"set",
"overwrite",
"bookmark",
"conflicts",
"(",
"boolean",
"b",
")",
"{",
"overwrite",
"bookmark",
"conflicts",
"=",
"b",
";",
"}"
] |
[
"get",
"the",
"{",
"@",
"link",
"category",
"path",
"}",
"associated",
"with",
"the",
"{",
"@",
"link",
"symbol",
"path",
"}",
"specified",
",",
"rooting",
"it",
"either",
"at",
"the",
"pdb",
"category"
] | [
"public",
"category",
"path",
"get",
"category",
"(",
"symbol",
"path",
"symbol",
"path",
")",
"{",
"category",
"path",
"category",
"=",
"pdb",
"root",
"category",
";",
"if",
"(",
"symbol",
"path",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"global",
"namespace",
"return",
"category",
";",
"}",
"return",
"recurse",
"get",
"category",
"path",
"(",
"category",
",",
"symbol",
"path",
")",
";",
"}"
] |
[
"retrieve",
"the",
"message",
"for",
"the",
"given",
"code",
",",
"using",
"the",
"\"",
"default",
"html",
"escape",
"\"",
"setting"
] | [
"public",
"string",
"get",
"message",
"(",
"string",
"code",
",",
"@",
"nullable",
"list",
"<",
"?",
">",
"args",
")",
"throws",
"no",
"such",
"message",
"exception",
"{",
"return",
"get",
"message",
"(",
"code",
",",
"(",
"args",
"!",
"=",
"null",
"?",
"args",
"to",
"array",
"(",
")",
":",
"null",
")",
",",
"is",
"default",
"html",
"escape",
"(",
")",
")",
";",
"}"
] |
[
"dialog",
"with",
"only",
"yesno",
"options",
",",
"<",
"b",
">",
"no",
"cancel",
"<",
"b",
">"
] | [
"public",
"static",
"int",
"show",
"yes",
"no",
"cancel",
"dialog",
"(",
"component",
"parent",
",",
"string",
"title",
",",
"string",
"message",
")",
"{",
"return",
"show",
"option",
"dialog",
"(",
"parent",
",",
"title",
",",
"message",
",",
"\"",
"&",
"yes",
"\"",
",",
"\"",
"&",
"no",
"\"",
",",
"question",
"message",
")",
";",
"}"
] |
[
"sets",
"{",
"@",
"link",
"format",
"#",
"rotation",
"degrees",
"}",
"the",
"default",
"value",
"is",
"0"
] | [
"public",
"builder",
"set",
"rotation",
"degrees",
"(",
"int",
"rotation",
"degrees",
")",
"{",
"this",
"rotation",
"degrees",
"=",
"rotation",
"degrees",
";",
"return",
"this",
";",
"}"
] |
[
"test",
"the",
"removal",
"of",
"a",
"dynamic",
"leaf",
"under",
"a",
"hierarchy",
"of",
"static",
"parents"
] | [
"public",
"void",
"test",
"removal",
"of",
"dynamic",
"leaf",
"queue",
"(",
")",
"{",
"f",
"s",
"leaf",
"queue",
"q",
"1",
"=",
"queue",
"manager",
"get",
"leaf",
"queue",
"(",
"\"",
"root",
"test",
"child",
"b",
"dynamic",
"1",
"\"",
",",
"true",
")",
";",
"assert",
"not",
"null",
"(",
"\"",
"queue",
"root",
"test",
"child",
"b",
"dynamic",
"1",
"was",
"not",
"created",
"\"",
",",
"q",
"1",
")",
";",
"assert",
"equals",
"(",
"\"",
"create",
"queue",
"(",
")",
"returned",
"wrong",
"queue",
"\"",
",",
"\"",
"root",
"test",
"child",
"b",
"dynamic",
"1",
"\"",
",",
"q",
"1",
"get",
"name",
"(",
")",
")",
";",
"assert",
"true",
"(",
"\"",
"root",
"test",
"child",
"b",
"dynamic",
"1",
"is",
"not",
"a",
"dynamic",
"queue",
"\"",
",",
"q",
"1",
"is",
"dynamic",
"(",
")",
")",
";",
"/",
"/",
"an",
"application",
"is",
"submitted",
"to",
"root",
"test",
"child",
"b",
"dynamic",
"1",
"application",
"id",
"app",
"id",
"=",
"application",
"id",
"new",
"instance",
"(",
"0",
",",
"0",
")",
";",
"q",
"1",
"add",
"assigned",
"app",
"(",
"app",
"id",
")",
";",
"/",
"/",
"root",
"test",
"child",
"b",
"dynamic",
"1",
"is",
"not",
"empty",
"and",
"should",
"not",
"be",
"removed",
"queue",
"manager",
"remove",
"pending",
"incompatible",
"queues",
"(",
")",
";",
"queue",
"manager",
"remove",
"empty",
"dynamic",
"queues",
"(",
")",
";",
"q",
"1",
"=",
"queue",
"manager",
"get",
"leaf",
"queue",
"(",
"\"",
"root",
"test",
"child",
"b",
"dynamic",
"1",
"\"",
",",
"false",
")",
";",
"assert",
"not",
"null",
"(",
"\"",
"queue",
"root",
"test",
"child",
"b",
"dynamic",
"1",
"was",
"deleted",
"\"",
",",
"q",
"1",
")",
";",
"/",
"/",
"the",
"application",
"finishes",
",",
"the",
"next",
"remove",
"empty",
"dynamic",
"queues",
"(",
")",
"should",
"/",
"/",
"clean",
"root",
"test",
"child",
"b",
"dynamic",
"1",
"up",
",",
"but",
"keep",
"its",
"static",
"parent",
"q",
"1",
"remove",
"assigned",
"app",
"(",
"app",
"id",
")",
";",
"queue",
"manager",
"remove",
"pending",
"incompatible",
"queues",
"(",
")",
";",
"queue",
"manager",
"remove",
"empty",
"dynamic",
"queues",
"(",
")",
";",
"q",
"1",
"=",
"queue",
"manager",
"get",
"leaf",
"queue",
"(",
"\"",
"root",
"test",
"child",
"b",
"dynamic",
"1",
"\"",
",",
"false",
")",
";",
"assert",
"null",
"(",
"\"",
"queue",
"root",
"test",
"child",
"b",
"dynamic",
"1",
"was",
"not",
"deleted",
"\"",
",",
"q",
"1",
")",
";",
"assert",
"not",
"null",
"(",
"\"",
"the",
"static",
"parent",
"of",
"root",
"test",
"child",
"b",
"dynamic",
"1",
"was",
"deleted",
"\"",
",",
"queue",
"manager",
"get",
"parent",
"queue",
"(",
"\"",
"root",
"test",
"child",
"b",
"\"",
",",
"false",
")",
")",
";",
"}"
] |
[
"returns",
"the",
"appropriate",
"{",
"@",
"code",
"return",
"}",
"rop",
"for",
"the",
"given",
"type",
"the",
"result",
"is",
"a",
"shared",
"instance"
] | [
"public",
"static",
"rop",
"op",
"return",
"(",
"type",
"bearer",
"type",
")",
"{",
"switch",
"(",
"type",
"get",
"basic",
"frame",
"type",
"(",
")",
")",
"{",
"case",
"type",
"bt",
"int",
":",
"return",
"return",
"int",
";",
"case",
"type",
"bt",
"long",
":",
"return",
"return",
"long",
";",
"case",
"type",
"bt",
"float",
":",
"return",
"return",
"float",
";",
"case",
"type",
"bt",
"double",
":",
"return",
"return",
"double",
";",
"case",
"type",
"bt",
"object",
":",
"return",
"return",
"object",
";",
"case",
"type",
"bt",
"void",
":",
"return",
"return",
"void",
";",
"}",
"return",
"throw",
"bad",
"type",
"(",
"type",
")",
";",
"}"
] |
[
"adds",
"a",
"collection",
"of",
"false",
"positive",
"information",
"to",
"this",
"retouched",
"bloom",
"filter"
] | [
"public",
"void",
"add",
"false",
"positive",
"(",
"collection",
"<",
"key",
">",
"coll",
")",
"{",
"if",
"(",
"coll",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"null",
"pointer",
"exception",
"(",
"\"",
"collection",
"<",
"key",
">",
"can",
"not",
"be",
"null",
"\"",
")",
";",
"}",
"for",
"(",
"key",
"k",
":",
"coll",
")",
"{",
"add",
"false",
"positive",
"(",
"k",
")",
";",
"}",
"}"
] |
[
"return",
"the",
"passcode",
"used",
"for",
"the",
"shared",
"\"",
"system",
"\"",
"connection",
"to",
"the",
"stomp",
"broker"
] | [
"public",
"string",
"get",
"system",
"passcode",
"(",
")",
"{",
"return",
"this",
"system",
"passcode",
";",
"}"
] |
[
"where",
"the",
"enumflag",
"item",
"was",
"defined",
"<",
"code",
">",
"optional",
"aapt",
"pb",
"source",
"source",
"=",
"1",
";",
"<",
"code",
">"
] | [
"private",
"void",
"merge",
"source",
"(",
"com",
"android",
"aapt",
"resources",
"source",
"value",
")",
"{",
"if",
"(",
"source",
"!",
"=",
"null",
"&",
"&",
"source",
"!",
"=",
"com",
"android",
"aapt",
"resources",
"source",
"get",
"default",
"instance",
"(",
")",
")",
"{",
"source",
"=",
"com",
"android",
"aapt",
"resources",
"source",
"new",
"builder",
"(",
"source",
")",
"merge",
"from",
"(",
"value",
")",
"build",
"partial",
"(",
")",
";",
"}",
"else",
"{",
"source",
"=",
"value",
";",
"}",
"bit",
"field",
"0",
"|",
"=",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"1",
";",
"}"
] |
[
"creates",
"results",
"for",
"a",
"file",
"or",
"for",
"a",
"symlink",
"that",
"points",
"to",
"one",
"a",
"symlink",
"may",
"be",
"direct",
"(",
"points",
"to",
"a",
"file",
")",
"or",
"transitive",
"(",
"points",
"at",
"a",
"direct",
"or",
"transitive",
"symlink",
")"
] | [
"private",
"static",
"recursive",
"filesystem",
"traversal",
"value",
"result",
"for",
"file",
"root",
"(",
"rooted",
"path",
"path",
",",
"file",
"info",
"info",
")",
"{",
"preconditions",
"check",
"state",
"(",
"info",
"type",
"is",
"file",
"(",
")",
"&",
"&",
"info",
"type",
"exists",
"(",
")",
",",
"\"",
"{",
"%",
"s",
"}",
"{",
"%",
"s",
"}",
"\"",
",",
"path",
",",
"info",
"type",
")",
";",
"if",
"(",
"info",
"type",
"is",
"symlink",
"(",
")",
")",
"{",
"return",
"recursive",
"filesystem",
"traversal",
"value",
"of",
"(",
"resolved",
"file",
"factory",
"symlink",
"to",
"file",
"(",
"info",
"real",
"path",
",",
"path",
",",
"info",
"unresolved",
"symlink",
"target",
",",
"info",
"metadata",
")",
")",
";",
"}",
"else",
"{",
"return",
"recursive",
"filesystem",
"traversal",
"value",
"of",
"(",
"resolved",
"file",
"factory",
"regular",
"file",
"(",
"path",
",",
"info",
"metadata",
")",
")",
";",
"}",
"}"
] |
[
"this",
"method",
"allows",
"for",
"ext4",
"files",
"larger",
"than",
"2gb",
"to",
"be",
"imported",
"as",
"2",
"(",
"or",
"3",
")",
"separate",
"programs",
"then",
"if",
"both",
"programs",
"are",
"opened",
"(",
"and",
"have",
"the",
"same",
"base",
"name",
")",
",",
"then",
"both",
"will",
"be",
"analyzed"
] | [
"private",
"program",
"find",
"other",
"program",
"(",
"program",
"program",
",",
"string",
"suffix",
")",
"{",
"auto",
"analysis",
"manager",
"manager",
"=",
"auto",
"analysis",
"manager",
"get",
"analysis",
"manager",
"(",
"program",
")",
";",
"program",
"manager",
"program",
"manager",
"=",
"manager",
"get",
"analysis",
"tool",
"(",
")",
"get",
"service",
"(",
"program",
"manager",
"class",
")",
";",
"program",
"[",
"]",
"open",
"programs",
"=",
"program",
"manager",
"get",
"all",
"open",
"programs",
"(",
")",
";",
"for",
"(",
"program",
"other",
"program",
":",
"open",
"programs",
")",
"{",
"if",
"(",
"program",
"!",
"=",
"other",
"program",
")",
"{",
"if",
"(",
"other",
"program",
"get",
"name",
"(",
")",
"starts",
"with",
"(",
"program",
"get",
"name",
"(",
")",
")",
"&",
"&",
"other",
"program",
"get",
"name",
"(",
")",
"ends",
"with",
"(",
"suffix",
")",
")",
"{",
"return",
"other",
"program",
";",
"}",
"}",
"}",
"return",
"null",
";",
"/",
"/",
"not",
"using",
"a",
"2nd",
"program",
"}"
] |
[
"set",
"block",
"keys",
",",
"only",
"to",
"be",
"used",
"in",
"worker",
"mode"
] | [
"public",
"synchronized",
"void",
"add",
"keys",
"(",
"exported",
"block",
"keys",
"exported",
"keys",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"is",
"master",
"|",
"|",
"exported",
"keys",
"=",
"=",
"null",
")",
"{",
"return",
";",
"}",
"log",
"info",
"(",
"\"",
"setting",
"block",
"keys",
"\"",
")",
";",
"remove",
"expired",
"keys",
"(",
")",
";",
"this",
"current",
"key",
"=",
"exported",
"keys",
"get",
"current",
"key",
"(",
")",
";",
"block",
"key",
"[",
"]",
"received",
"keys",
"=",
"exported",
"keys",
"get",
"all",
"keys",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"received",
"keys",
"length",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"received",
"keys",
"[",
"i",
"]",
"!",
"=",
"null",
")",
"{",
"this",
"all",
"keys",
"put",
"(",
"received",
"keys",
"[",
"i",
"]",
"get",
"key",
"id",
"(",
")",
",",
"received",
"keys",
"[",
"i",
"]",
")",
";",
"}",
"}",
"}"
] |
[
"set",
"the",
"query",
"size",
"parameter"
] | [
"public",
"scheduled",
"events",
"query",
"builder",
"size",
"(",
"integer",
"size",
")",
"{",
"this",
"size",
"=",
"size",
";",
"return",
"this",
";",
"}"
] |
[
"removes",
"the",
"ec",
"headers",
"that",
"open",
"s",
"s",
"l",
"adds",
"to",
"ec",
"private",
"keys",
"as",
"the",
"information",
"in",
"them",
"is",
"redundant"
] | [
"private",
"static",
"buffered",
"reader",
"remove",
"e",
"c",
"headers",
"(",
"buffered",
"reader",
"b",
"reader",
")",
"throws",
"i",
"o",
"exception",
"{",
"string",
"line",
"=",
"b",
"reader",
"read",
"line",
"(",
")",
";",
"while",
"(",
"line",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"openssl",
"ec",
"params",
"footer",
"equals",
"(",
"line",
"trim",
"(",
")",
")",
")",
"{",
"break",
";",
"}",
"line",
"=",
"b",
"reader",
"read",
"line",
"(",
")",
";",
"}",
"if",
"(",
"null",
"=",
"=",
"line",
"|",
"|",
"openssl",
"ec",
"params",
"footer",
"equals",
"(",
"line",
"trim",
"(",
")",
")",
"=",
"=",
"false",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"malformed",
"pem",
"file",
",",
"ec",
"parameters",
"footer",
"is",
"missing",
"\"",
")",
";",
"}",
"/",
"/",
"verify",
"that",
"the",
"key",
"starts",
"with",
"the",
"correct",
"header",
"before",
"passing",
"it",
"to",
"parse",
"open",
"ssl",
"e",
"c",
"if",
"(",
"openssl",
"ec",
"header",
"equals",
"(",
"b",
"reader",
"read",
"line",
"(",
")",
")",
"=",
"=",
"false",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"malformed",
"pem",
"file",
",",
"ec",
"key",
"header",
"is",
"missing",
"\"",
")",
";",
"}",
"return",
"b",
"reader",
";",
"}"
] |
[
"returns",
"an",
"immutable",
"sorted",
"multiset",
"containing",
"the",
"given",
"elements",
"sorted",
"by",
"their",
"natural",
"ordering"
] | [
"public",
"static",
"<",
"e",
"extends",
"comparable",
"<",
"?",
"super",
"e",
">",
">",
"immutable",
"sorted",
"multiset",
"<",
"e",
">",
"of",
"(",
"e",
"e",
"1",
",",
"e",
"e",
"2",
",",
"e",
"e",
"3",
",",
"e",
"e",
"4",
",",
"e",
"e",
"5",
")",
"{",
"return",
"copy",
"of",
"(",
"ordering",
"natural",
"(",
")",
",",
"arrays",
"as",
"list",
"(",
"e",
"1",
",",
"e",
"2",
",",
"e",
"3",
",",
"e",
"4",
",",
"e",
"5",
")",
")",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] | [
"public",
"constant",
"pool",
"get",
"constant",
"pool",
"(",
")",
"{",
"parse",
"to",
"interfaces",
"if",
"necessary",
"(",
")",
";",
"return",
"pool",
";",
"}"
] |
[
"add",
"a",
"img",
"(",
"image",
")",
"element"
] | [
"img",
"object",
"img",
"(",
"string",
"src",
")",
";"
] |
[
"set",
"the",
"name",
"of",
"the",
"task",
";",
"the",
"name",
"shows",
"up",
"in",
"the",
"tool",
"tip",
"for",
"the",
"cancel",
"button"
] | [
"public",
"void",
"set",
"task",
"name",
"(",
"string",
"name",
")",
"{",
"task",
"name",
"=",
"name",
";",
"system",
"utilities",
"run",
"swing",
"later",
"(",
"update",
"tool",
"tip",
"runnable",
")",
";",
"}"
] |
[
"sets",
"the",
"field",
"names",
"that",
"will",
"be",
"used",
"when",
"generating",
"the",
"'",
"more",
"like",
"this",
"'",
"query",
"set",
"this",
"to",
"null",
"for",
"the",
"field",
"names",
"to",
"be",
"determined",
"at",
"runtime",
"from",
"the",
"index",
"reader",
"provided",
"in",
"the",
"constructor"
] | [
"public",
"void",
"set",
"field",
"names",
"(",
"string",
"[",
"]",
"field",
"names",
")",
"{",
"this",
"field",
"names",
"=",
"field",
"names",
";",
"}"
] |
[
"sets",
"how",
"similar",
"the",
"suggested",
"terms",
"at",
"least",
"need",
"to",
"be",
"compared",
"to",
"the",
"original",
"suggest",
"text",
"tokens",
"a",
"value",
"between",
"0",
"and",
"1",
"can",
"be",
"specified",
"this",
"value",
"will",
"be",
"compared",
"to",
"the",
"string",
"distance",
"result",
"of",
"each",
"candidate",
"spelling",
"correction",
"default",
"is",
"{",
"@",
"code",
"0",
"5",
"}"
] | [
"public",
"direct",
"candidate",
"generator",
"builder",
"accuracy",
"(",
"float",
"accuracy",
")",
"{",
"this",
"accuracy",
"=",
"accuracy",
";",
"return",
"this",
";",
"}"
] |
[
"converts",
"the",
"specified",
"xml",
"element",
"into",
"a",
"byte",
"array"
] | [
"public",
"static",
"byte",
"[",
"]",
"xml",
"to",
"byte",
"array",
"(",
"element",
"root",
")",
"{",
"byte",
"array",
"output",
"stream",
"os",
"=",
"new",
"byte",
"array",
"output",
"stream",
"(",
")",
";",
"document",
"doc",
"=",
"new",
"document",
"(",
"root",
")",
";",
"x",
"m",
"l",
"outputter",
"xml",
"out",
"=",
"new",
"generic",
"x",
"m",
"l",
"outputter",
"(",
")",
";",
"try",
"{",
"xml",
"out",
"output",
"(",
"doc",
",",
"os",
")",
";",
"os",
"close",
"(",
")",
";",
"return",
"os",
"to",
"byte",
"array",
"(",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"/",
"/",
"can",
"'",
"t",
"happen",
"}",
"return",
"null",
";",
"}"
] |
[
"performs",
"no",
"animation",
"and",
"always",
"returns",
"{",
"@",
"code",
"false",
"}"
] | [
"public",
"boolean",
"transition",
"(",
"object",
"current",
",",
"view",
"adapter",
"adapter",
")",
"{",
"return",
"false",
";",
"}"
] |
[
"returns",
"the",
"actual",
"maximum",
"stack",
"size",
"that",
"was",
"required",
"for",
"all",
"stack",
"operations",
",",
"accounting",
"for",
"the",
"double",
"space",
"required",
"by",
"category",
"2",
"values"
] | [
"public",
"int",
"get",
"actual",
"max",
"size",
"(",
")",
"{",
"return",
"actual",
"max",
"size",
";",
"}"
] |
[
"configures",
"the",
"given",
"{",
"@",
"link",
"s",
"a",
"x",
"reader",
"}"
] | [
"public",
"void",
"configure",
"(",
"s",
"a",
"x",
"reader",
"reader",
",",
"object",
"context",
")",
"{",
"}"
] |
[
"adds",
"a",
"file",
"to",
"the",
"current",
"zip",
"output",
"stream"
] | [
"private",
"static",
"void",
"add",
"file",
"to",
"zip",
"(",
"file",
"file",
",",
"zip",
"output",
"stream",
"zos",
")",
"throws",
"file",
"not",
"found",
"exception",
",",
"i",
"o",
"exception",
"{",
"zos",
"put",
"next",
"entry",
"(",
"new",
"zip",
"entry",
"(",
"file",
"get",
"name",
"(",
")",
")",
")",
";",
"try",
"(",
"buffered",
"input",
"stream",
"bis",
"=",
"new",
"buffered",
"input",
"stream",
"(",
"new",
"file",
"input",
"stream",
"(",
"file",
")",
")",
")",
"{",
"byte",
"[",
"]",
"bytes",
"in",
"=",
"new",
"byte",
"[",
"buffer",
"size",
"]",
";",
"int",
"read",
";",
"while",
"(",
"(",
"read",
"=",
"bis",
"read",
"(",
"bytes",
"in",
")",
")",
"!",
"=",
"-",
"1",
")",
"{",
"zos",
"write",
"(",
"bytes",
"in",
",",
"0",
",",
"read",
")",
";",
"}",
"}",
"zos",
"close",
"entry",
"(",
")",
";",
"}"
] |
[
"make",
"sure",
"all",
"required",
"services",
"have",
"been",
"implemented"
] | [
"void",
"required",
"check",
"(",
"class",
"<",
"?",
"extends",
"service",
">",
"[",
"]",
"required",
"services",
")",
"throws",
"service",
"not",
"provided",
"exception",
"{",
"if",
"(",
"required",
"services",
"=",
"=",
"null",
")",
"return",
";",
"for",
"(",
"class",
"<",
"?",
"extends",
"service",
">",
"service",
":",
"required",
"services",
")",
"{",
"if",
"(",
"!",
"services",
"contains",
"key",
"(",
"service",
")",
")",
"{",
"throw",
"new",
"service",
"not",
"provided",
"exception",
"(",
"\"",
"service",
":",
"\"",
"+",
"service",
"get",
"name",
"(",
")",
"+",
"\"",
"not",
"provided",
"\"",
")",
";",
"}",
"}",
"if",
"(",
"required",
"services",
"length",
"!",
"=",
"services",
"size",
"(",
")",
")",
"{",
"throw",
"new",
"service",
"not",
"provided",
"exception",
"(",
"\"",
"the",
"\"",
"+",
"this",
"name",
"(",
")",
"+",
"\"",
"provider",
"in",
"\"",
"+",
"module",
"define",
"name",
"(",
")",
"+",
"\"",
"module",
"define",
"provide",
"more",
"service",
"implementations",
"than",
"module",
"define",
"requirements",
"\"",
")",
";",
"}",
"}"
] |
[
"return",
"the",
"blur",
"bitmap",
"using",
"stack"
] | [
"public",
"static",
"bitmap",
"stack",
"blur",
"(",
"final",
"bitmap",
"src",
",",
"int",
"radius",
",",
"final",
"boolean",
"recycle",
")",
"{",
"bitmap",
"ret",
"=",
"recycle",
"?",
"src",
":",
"src",
"copy",
"(",
"src",
"get",
"config",
"(",
")",
",",
"true",
")",
";",
"if",
"(",
"radius",
"<",
"1",
")",
"{",
"radius",
"=",
"1",
";",
"}",
"int",
"w",
"=",
"ret",
"get",
"width",
"(",
")",
";",
"int",
"h",
"=",
"ret",
"get",
"height",
"(",
")",
";",
"int",
"[",
"]",
"pix",
"=",
"new",
"int",
"[",
"w",
"*",
"h",
"]",
";",
"ret",
"get",
"pixels",
"(",
"pix",
",",
"0",
",",
"w",
",",
"0",
",",
"0",
",",
"w",
",",
"h",
")",
";",
"int",
"wm",
"=",
"w",
"-",
"1",
";",
"int",
"hm",
"=",
"h",
"-",
"1",
";",
"int",
"wh",
"=",
"w",
"*",
"h",
";",
"int",
"div",
"=",
"radius",
"+",
"radius",
"+",
"1",
";",
"int",
"r",
"[",
"]",
"=",
"new",
"int",
"[",
"wh",
"]",
";",
"int",
"g",
"[",
"]",
"=",
"new",
"int",
"[",
"wh",
"]",
";",
"int",
"b",
"[",
"]",
"=",
"new",
"int",
"[",
"wh",
"]",
";",
"int",
"rsum",
",",
"gsum",
",",
"bsum",
",",
"x",
",",
"y",
",",
"i",
",",
"p",
",",
"yp",
",",
"yi",
",",
"yw",
";",
"int",
"vmin",
"[",
"]",
"=",
"new",
"int",
"[",
"math",
"max",
"(",
"w",
",",
"h",
")",
"]",
";",
"int",
"divsum",
"=",
"(",
"div",
"+",
"1",
")",
">",
">",
"1",
";",
"divsum",
"*",
"=",
"divsum",
";",
"int",
"dv",
"[",
"]",
"=",
"new",
"int",
"[",
"256",
"*",
"divsum",
"]",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"256",
"*",
"divsum",
";",
"i",
"+",
"+",
")",
"{",
"dv",
"[",
"i",
"]",
"=",
"(",
"i",
"/",
"divsum",
")",
";",
"}",
"yw",
"=",
"yi",
"=",
"0",
";",
"int",
"[",
"]",
"[",
"]",
"stack",
"=",
"new",
"int",
"[",
"div",
"]",
"[",
"3",
"]",
";",
"int",
"stackpointer",
";",
"int",
"stackstart",
";",
"int",
"[",
"]",
"sir",
";",
"int",
"rbs",
";",
"int",
"r",
"1",
"=",
"radius",
"+",
"1",
";",
"int",
"routsum",
",",
"goutsum",
",",
"boutsum",
";",
"int",
"rinsum",
",",
"ginsum",
",",
"binsum",
";",
"for",
"(",
"y",
"=",
"0",
";",
"y",
"<",
"h",
";",
"y",
"+",
"+",
")",
"{",
"rinsum",
"=",
"ginsum",
"=",
"binsum",
"=",
"routsum",
"=",
"goutsum",
"=",
"boutsum",
"=",
"rsum",
"=",
"gsum",
"=",
"bsum",
"=",
"0",
";",
"for",
"(",
"i",
"=",
"-",
"radius",
";",
"i",
"<",
"=",
"radius",
";",
"i",
"+",
"+",
")",
"{",
"p",
"=",
"pix",
"[",
"yi",
"+",
"math",
"min",
"(",
"wm",
",",
"math",
"max",
"(",
"i",
",",
"0",
")",
")",
"]",
";",
"sir",
"=",
"stack",
"[",
"i",
"+",
"radius",
"]",
";",
"sir",
"[",
"0",
"]",
"=",
"(",
"p",
"&",
"0xff",
"0",
"0",
"0",
"0",
")",
">",
">",
"16",
";",
"sir",
"[",
"1",
"]",
"=",
"(",
"p",
"&",
"0x",
"0",
"0ff",
"0",
"0",
")",
">",
">",
"8",
";",
"sir",
"[",
"2",
"]",
"=",
"(",
"p",
"&",
"0x",
"0",
"0",
"0",
"0ff",
")",
";",
"rbs",
"=",
"r",
"1",
"-",
"math",
"abs",
"(",
"i",
")",
";",
"rsum",
"+",
"=",
"sir",
"[",
"0",
"]",
"*",
"rbs",
";",
"gsum",
"+",
"=",
"sir",
"[",
"1",
"]",
"*",
"rbs",
";",
"bsum",
"+",
"=",
"sir",
"[",
"2",
"]",
"*",
"rbs",
";",
"if",
"(",
"i",
">",
"0",
")",
"{",
"rinsum",
"+",
"=",
"sir",
"[",
"0",
"]",
";",
"ginsum",
"+",
"=",
"sir",
"[",
"1",
"]",
";",
"binsum",
"+",
"=",
"sir",
"[",
"2",
"]",
";",
"}",
"else",
"{",
"routsum",
"+",
"=",
"sir",
"[",
"0",
"]",
";",
"goutsum",
"+",
"=",
"sir",
"[",
"1",
"]",
";",
"boutsum",
"+",
"=",
"sir",
"[",
"2",
"]",
";",
"}",
"}",
"stackpointer",
"=",
"radius",
";",
"for",
"(",
"x",
"=",
"0",
";",
"x",
"<",
"w",
";",
"x",
"+",
"+",
")",
"{",
"r",
"[",
"yi",
"]",
"=",
"dv",
"[",
"rsum",
"]",
";",
"g",
"[",
"yi",
"]",
"=",
"dv",
"[",
"gsum",
"]",
";",
"b",
"[",
"yi",
"]",
"=",
"dv",
"[",
"bsum",
"]",
";",
"rsum",
"-",
"=",
"routsum",
";",
"gsum",
"-",
"=",
"goutsum",
";",
"bsum",
"-",
"=",
"boutsum",
";",
"stackstart",
"=",
"stackpointer",
"-",
"radius",
"+",
"div",
";",
"sir",
"=",
"stack",
"[",
"stackstart",
"%",
"div",
"]",
";",
"routsum",
"-",
"=",
"sir",
"[",
"0",
"]",
";",
"goutsum",
"-",
"=",
"sir",
"[",
"1",
"]",
";",
"boutsum",
"-",
"=",
"sir",
"[",
"2",
"]",
";",
"if",
"(",
"y",
"=",
"=",
"0",
")",
"{",
"vmin",
"[",
"x",
"]",
"=",
"math",
"min",
"(",
"x",
"+",
"radius",
"+",
"1",
",",
"wm",
")",
";",
"}",
"p",
"=",
"pix",
"[",
"yw",
"+",
"vmin",
"[",
"x",
"]",
"]",
";",
"sir",
"[",
"0",
"]",
"=",
"(",
"p",
"&",
"0xff",
"0",
"0",
"0",
"0",
")",
">",
">",
"16",
";",
"sir",
"[",
"1",
"]",
"=",
"(",
"p",
"&",
"0x",
"0",
"0ff",
"0",
"0",
")",
">",
">",
"8",
";",
"sir",
"[",
"2",
"]",
"=",
"(",
"p",
"&",
"0x",
"0",
"0",
"0",
"0ff",
")",
";",
"rinsum",
"+",
"=",
"sir",
"[",
"0",
"]",
";",
"ginsum",
"+",
"=",
"sir",
"[",
"1",
"]",
";",
"binsum",
"+",
"=",
"sir",
"[",
"2",
"]",
";",
"rsum",
"+",
"=",
"rinsum",
";",
"gsum",
"+",
"=",
"ginsum",
";",
"bsum",
"+",
"=",
"binsum",
";",
"stackpointer",
"=",
"(",
"stackpointer",
"+",
"1",
")",
"%",
"div",
";",
"sir",
"=",
"stack",
"[",
"(",
"stackpointer",
")",
"%",
"div",
"]",
";",
"routsum",
"+",
"=",
"sir",
"[",
"0",
"]",
";",
"goutsum",
"+",
"=",
"sir",
"[",
"1",
"]",
";",
"boutsum",
"+",
"=",
"sir",
"[",
"2",
"]",
";",
"rinsum",
"-",
"=",
"sir",
"[",
"0",
"]",
";",
"ginsum",
"-",
"=",
"sir",
"[",
"1",
"]",
";",
"binsum",
"-",
"=",
"sir",
"[",
"2",
"]",
";",
"yi",
"+",
"+",
";",
"}",
"yw",
"+",
"=",
"w",
";",
"}",
"for",
"(",
"x",
"=",
"0",
";",
"x",
"<",
"w",
";",
"x",
"+",
"+",
")",
"{",
"rinsum",
"=",
"ginsum",
"=",
"binsum",
"=",
"routsum",
"=",
"goutsum",
"=",
"boutsum",
"=",
"rsum",
"=",
"gsum",
"=",
"bsum",
"=",
"0",
";",
"yp",
"=",
"-",
"radius",
"*",
"w",
";",
"for",
"(",
"i",
"=",
"-",
"radius",
";",
"i",
"<",
"=",
"radius",
";",
"i",
"+",
"+",
")",
"{",
"yi",
"=",
"math",
"max",
"(",
"0",
",",
"yp",
")",
"+",
"x",
";",
"sir",
"=",
"stack",
"[",
"i",
"+",
"radius",
"]",
";",
"sir",
"[",
"0",
"]",
"=",
"r",
"[",
"yi",
"]",
";",
"sir",
"[",
"1",
"]",
"=",
"g",
"[",
"yi",
"]",
";",
"sir",
"[",
"2",
"]",
"=",
"b",
"[",
"yi",
"]",
";",
"rbs",
"=",
"r",
"1",
"-",
"math",
"abs",
"(",
"i",
")",
";",
"rsum",
"+",
"=",
"r",
"[",
"yi",
"]",
"*",
"rbs",
";",
"gsum",
"+",
"=",
"g",
"[",
"yi",
"]",
"*",
"rbs",
";",
"bsum",
"+",
"=",
"b",
"[",
"yi",
"]",
"*",
"rbs",
";",
"if",
"(",
"i",
">",
"0",
")",
"{",
"rinsum",
"+",
"=",
"sir",
"[",
"0",
"]",
";",
"ginsum",
"+",
"=",
"sir",
"[",
"1",
"]",
";",
"binsum",
"+",
"=",
"sir",
"[",
"2",
"]",
";",
"}",
"else",
"{",
"routsum",
"+",
"=",
"sir",
"[",
"0",
"]",
";",
"goutsum",
"+",
"=",
"sir",
"[",
"1",
"]",
";",
"boutsum",
"+",
"=",
"sir",
"[",
"2",
"]",
";",
"}",
"if",
"(",
"i",
"<",
"hm",
")",
"{",
"yp",
"+",
"=",
"w",
";",
"}",
"}",
"yi",
"=",
"x",
";",
"stackpointer",
"=",
"radius",
";",
"for",
"(",
"y",
"=",
"0",
";",
"y",
"<",
"h",
";",
"y",
"+",
"+",
")",
"{",
"/",
"/",
"preserve",
"alpha",
"channel",
":",
"(",
"0xff",
"0",
"0",
"0",
"0",
"0",
"0",
"&",
"pix",
"[",
"yi",
"]",
")",
"pix",
"[",
"yi",
"]",
"=",
"(",
"0xff",
"0",
"0",
"0",
"0",
"0",
"0",
"&",
"pix",
"[",
"yi",
"]",
")",
"|",
"(",
"dv",
"[",
"rsum",
"]",
"<",
"<",
"16",
")",
"|",
"(",
"dv",
"[",
"gsum",
"]",
"<",
"<",
"8",
")",
"|",
"dv",
"[",
"bsum",
"]",
";",
"rsum",
"-",
"=",
"routsum",
";",
"gsum",
"-",
"=",
"goutsum",
";",
"bsum",
"-",
"=",
"boutsum",
";",
"stackstart",
"=",
"stackpointer",
"-",
"radius",
"+",
"div",
";",
"sir",
"=",
"stack",
"[",
"stackstart",
"%",
"div",
"]",
";",
"routsum",
"-",
"=",
"sir",
"[",
"0",
"]",
";",
"goutsum",
"-",
"=",
"sir",
"[",
"1",
"]",
";",
"boutsum",
"-",
"=",
"sir",
"[",
"2",
"]",
";",
"if",
"(",
"x",
"=",
"=",
"0",
")",
"{",
"vmin",
"[",
"y",
"]",
"=",
"math",
"min",
"(",
"y",
"+",
"r",
"1",
",",
"hm",
")",
"*",
"w",
";",
"}",
"p",
"=",
"x",
"+",
"vmin",
"[",
"y",
"]",
";",
"sir",
"[",
"0",
"]",
"=",
"r",
"[",
"p",
"]",
";",
"sir",
"[",
"1",
"]",
"=",
"g",
"[",
"p",
"]",
";",
"sir",
"[",
"2",
"]",
"=",
"b",
"[",
"p",
"]",
";",
"rinsum",
"+",
"=",
"sir",
"[",
"0",
"]",
";",
"ginsum",
"+",
"=",
"sir",
"[",
"1",
"]",
";",
"binsum",
"+",
"=",
"sir",
"[",
"2",
"]",
";",
"rsum",
"+",
"=",
"rinsum",
";",
"gsum",
"+",
"=",
"ginsum",
";",
"bsum",
"+",
"=",
"binsum",
";",
"stackpointer",
"=",
"(",
"stackpointer",
"+",
"1",
")",
"%",
"div",
";",
"sir",
"=",
"stack",
"[",
"stackpointer",
"]",
";",
"routsum",
"+",
"=",
"sir",
"[",
"0",
"]",
";",
"goutsum",
"+",
"=",
"sir",
"[",
"1",
"]",
";",
"boutsum",
"+",
"=",
"sir",
"[",
"2",
"]",
";",
"rinsum",
"-",
"=",
"sir",
"[",
"0",
"]",
";",
"ginsum",
"-",
"=",
"sir",
"[",
"1",
"]",
";",
"binsum",
"-",
"=",
"sir",
"[",
"2",
"]",
";",
"yi",
"+",
"=",
"w",
";",
"}",
"}",
"ret",
"set",
"pixels",
"(",
"pix",
",",
"0",
",",
"w",
",",
"0",
",",
"0",
",",
"w",
",",
"h",
")",
";",
"return",
"ret",
";",
"}"
] |
[
"get",
"the",
"distance",
"of",
"this",
"mapping"
] | [
"int",
"get",
"distance",
"(",
")",
"{",
"return",
"this",
"distance",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.