docstring_tokens
list | code_tokens
list |
|---|---|
[
"utility",
"to",
"replace",
"null",
"with",
"default",
"rack"
] |
[
"private",
"static",
"string",
"get",
"rack",
"(",
"string",
"rack",
"string",
")",
"{",
"return",
"rack",
"string",
"=",
"=",
"null",
"?",
"network",
"topology",
"default",
"rack",
":",
"rack",
"string",
";",
"}"
] |
[
"copy",
"the",
"meta",
"data",
"from",
"another",
"encoded",
"image"
] |
[
"public",
"void",
"copy",
"meta",
"data",
"from",
"(",
"encoded",
"image",
"encoded",
"image",
")",
"{",
"m",
"image",
"format",
"=",
"encoded",
"image",
"get",
"image",
"format",
"(",
")",
";",
"m",
"width",
"=",
"encoded",
"image",
"get",
"width",
"(",
")",
";",
"m",
"height",
"=",
"encoded",
"image",
"get",
"height",
"(",
")",
";",
"m",
"rotation",
"angle",
"=",
"encoded",
"image",
"get",
"rotation",
"angle",
"(",
")",
";",
"m",
"exif",
"orientation",
"=",
"encoded",
"image",
"get",
"exif",
"orientation",
"(",
")",
";",
"m",
"sample",
"size",
"=",
"encoded",
"image",
"get",
"sample",
"size",
"(",
")",
";",
"m",
"stream",
"size",
"=",
"encoded",
"image",
"get",
"size",
"(",
")",
";",
"m",
"bytes",
"range",
"=",
"encoded",
"image",
"get",
"bytes",
"range",
"(",
")",
";",
"m",
"color",
"space",
"=",
"encoded",
"image",
"get",
"color",
"space",
"(",
")",
";",
"m",
"has",
"parsed",
"metadata",
"=",
"encoded",
"image",
"has",
"parsed",
"meta",
"data",
"(",
")",
";",
"}"
] |
[
"builds",
"a",
"{",
"@",
"link",
"csv",
"reporter",
"}",
"with",
"the",
"given",
"properties",
",",
"writing",
"{",
"@",
"code",
"csv",
"}",
"files",
"to",
"the",
"given",
"directory"
] |
[
"public",
"csv",
"reporter",
"build",
"(",
"file",
"directory",
")",
"{",
"return",
"new",
"csv",
"reporter",
"(",
"registry",
",",
"directory",
",",
"locale",
",",
"separator",
",",
"rate",
"unit",
",",
"duration",
"unit",
",",
"clock",
",",
"filter",
",",
"executor",
",",
"shutdown",
"executor",
"on",
"stop",
",",
"csv",
"file",
"provider",
")",
";",
"}"
] |
[
"returns",
"the",
"{",
"@",
"link",
"flink",
"metadata",
"column",
"interval",
"}",
"statistic"
] |
[
"public",
"value",
"interval",
"get",
"column",
"interval",
"(",
"rel",
"node",
"rel",
",",
"int",
"index",
")",
"{",
"for",
"(",
";",
";",
")",
"{",
"try",
"{",
"return",
"column",
"interval",
"handler",
"get",
"column",
"interval",
"(",
"rel",
",",
"this",
",",
"index",
")",
";",
"}",
"catch",
"(",
"janino",
"rel",
"metadata",
"provider",
"no",
"handler",
"e",
")",
"{",
"column",
"interval",
"handler",
"=",
"revise",
"(",
"e",
"rel",
"class",
",",
"flink",
"metadata",
"column",
"interval",
"def",
")",
";",
"}",
"}",
"}"
] |
[
"test",
"the",
"property",
"'",
"namespace",
"wrapped",
"array",
"'"
] |
[
"public",
"void",
"namespace",
"wrapped",
"array",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"namespace",
"wrapped",
"array",
"}"
] |
[
"[",
"flink",
"-",
"6020",
"]",
"tests",
"that",
"concurrent",
"put",
"operations",
"will",
"only",
"upload",
"the",
"file",
"once",
"to",
"the",
"{",
"@",
"link",
"blob",
"store",
"}",
"and",
"that",
"the",
"files",
"are",
"not",
"corrupt",
"at",
"any",
"time"
] |
[
"private",
"void",
"test",
"concurrent",
"put",
"operations",
"(",
"@",
"nullable",
"final",
"job",
"i",
"d",
"job",
"id",
",",
"final",
"blob",
"key",
"blob",
"type",
"blob",
"type",
")",
"throws",
"i",
"o",
"exception",
",",
"interrupted",
"exception",
",",
"execution",
"exception",
"{",
"final",
"configuration",
"config",
"=",
"new",
"configuration",
"(",
")",
";",
"config",
"set",
"string",
"(",
"blob",
"server",
"options",
"storage",
"directory",
",",
"temporary",
"folder",
"new",
"folder",
"(",
")",
"get",
"absolute",
"path",
"(",
")",
")",
";",
"final",
"blob",
"store",
"blob",
"store",
"server",
"=",
"mock",
"(",
"blob",
"store",
"class",
")",
";",
"final",
"blob",
"store",
"blob",
"store",
"cache",
"=",
"mock",
"(",
"blob",
"store",
"class",
")",
";",
"int",
"concurrent",
"put",
"operations",
"=",
"2",
";",
"int",
"data",
"size",
"=",
"1024",
";",
"final",
"count",
"down",
"latch",
"count",
"down",
"latch",
"=",
"new",
"count",
"down",
"latch",
"(",
"concurrent",
"put",
"operations",
")",
";",
"final",
"byte",
"[",
"]",
"data",
"=",
"new",
"byte",
"[",
"data",
"size",
"]",
";",
"final",
"list",
"<",
"path",
">",
"jars",
";",
"if",
"(",
"blob",
"type",
"=",
"=",
"permanent",
"blob",
")",
"{",
"/",
"/",
"implement",
"via",
"jar",
"file",
"upload",
"instead",
":",
"file",
"tmp",
"file",
"=",
"temporary",
"folder",
"new",
"file",
"(",
")",
";",
"file",
"utils",
"write",
"byte",
"array",
"to",
"file",
"(",
"tmp",
"file",
",",
"data",
")",
";",
"jars",
"=",
"collections",
"singleton",
"list",
"(",
"new",
"path",
"(",
"tmp",
"file",
"get",
"absolute",
"path",
"(",
")",
")",
")",
";",
"}",
"else",
"{",
"jars",
"=",
"null",
";",
"}",
"collection",
"<",
"completable",
"future",
"<",
"blob",
"key",
">",
">",
"all",
"futures",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"concurrent",
"put",
"operations",
")",
";",
"executor",
"service",
"executor",
"=",
"executors",
"new",
"fixed",
"thread",
"pool",
"(",
"concurrent",
"put",
"operations",
")",
";",
"try",
"(",
"final",
"blob",
"server",
"server",
"=",
"new",
"blob",
"server",
"(",
"config",
",",
"blob",
"store",
"server",
")",
";",
"final",
"blob",
"cache",
"service",
"cache",
"=",
"new",
"blob",
"cache",
"service",
"(",
"config",
",",
"blob",
"store",
"cache",
",",
"new",
"inet",
"socket",
"address",
"(",
"\"",
"localhost",
"\"",
",",
"server",
"get",
"port",
"(",
")",
")",
")",
")",
"{",
"server",
"start",
"(",
")",
";",
"/",
"/",
"for",
"high",
"availability",
"final",
"inet",
"socket",
"address",
"server",
"address",
"=",
"new",
"inet",
"socket",
"address",
"(",
"\"",
"localhost",
"\"",
",",
"server",
"get",
"port",
"(",
")",
")",
";",
"/",
"/",
"uploading",
"ha",
"b",
"l",
"o",
"bs",
"works",
"on",
"blob",
"server",
"only",
"(",
"and",
",",
"for",
"now",
",",
"via",
"the",
"blob",
"client",
")",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"concurrent",
"put",
"operations",
";",
"i",
"+",
"+",
")",
"{",
"final",
"supplier",
"<",
"blob",
"key",
">",
"callable",
";",
"if",
"(",
"blob",
"type",
"=",
"=",
"permanent",
"blob",
")",
"{",
"/",
"/",
"cannot",
"use",
"a",
"blocking",
"stream",
"here",
"(",
"upload",
"only",
"possible",
"via",
"files",
")",
"callable",
"=",
"(",
")",
"-",
">",
"{",
"try",
"{",
"list",
"<",
"permanent",
"blob",
"key",
">",
"keys",
"=",
"blob",
"client",
"upload",
"files",
"(",
"server",
"address",
",",
"config",
",",
"job",
"id",
",",
"jars",
")",
";",
"assert",
"equals",
"(",
"1",
",",
"keys",
"size",
"(",
")",
")",
";",
"blob",
"key",
"uploaded",
"key",
"=",
"keys",
"get",
"(",
"0",
")",
";",
"/",
"/",
"check",
"the",
"uploaded",
"file",
"'",
"s",
"contents",
"(",
"concurrently",
")",
"verify",
"contents",
"(",
"server",
",",
"job",
"id",
",",
"uploaded",
"key",
",",
"data",
")",
";",
"return",
"uploaded",
"key",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"throw",
"new",
"completion",
"exception",
"(",
"new",
"flink",
"exception",
"(",
"\"",
"could",
"not",
"upload",
"blob",
"\"",
",",
"e",
")",
")",
";",
"}",
"}",
";",
"}",
"else",
"{",
"callable",
"=",
"(",
")",
"-",
">",
"{",
"try",
"{",
"blocking",
"input",
"stream",
"input",
"stream",
"=",
"new",
"blocking",
"input",
"stream",
"(",
"count",
"down",
"latch",
",",
"data",
")",
";",
"blob",
"key",
"uploaded",
"key",
"=",
"put",
"(",
"cache",
",",
"job",
"id",
",",
"input",
"stream",
",",
"blob",
"type",
")",
";",
"/",
"/",
"check",
"the",
"uploaded",
"file",
"'",
"s",
"contents",
"(",
"concurrently",
")",
"verify",
"contents",
"(",
"server",
",",
"job",
"id",
",",
"uploaded",
"key",
",",
"data",
")",
";",
"return",
"uploaded",
"key",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"throw",
"new",
"completion",
"exception",
"(",
"new",
"flink",
"exception",
"(",
"\"",
"could",
"not",
"upload",
"blob",
"\"",
",",
"e",
")",
")",
";",
"}",
"}",
";",
"}",
"completable",
"future",
"<",
"blob",
"key",
">",
"put",
"future",
"=",
"completable",
"future",
"supply",
"async",
"(",
"callable",
",",
"executor",
")",
";",
"all",
"futures",
"add",
"(",
"put",
"future",
")",
";",
"}",
"future",
"utils",
"conjunct",
"future",
"<",
"collection",
"<",
"blob",
"key",
">",
">",
"conjunct",
"future",
"=",
"future",
"utils",
"combine",
"all",
"(",
"all",
"futures",
")",
";",
"/",
"/",
"wait",
"until",
"all",
"operations",
"have",
"completed",
"and",
"check",
"that",
"no",
"exception",
"was",
"thrown",
"collection",
"<",
"blob",
"key",
">",
"blob",
"keys",
"=",
"conjunct",
"future",
"get",
"(",
")",
";",
"iterator",
"<",
"blob",
"key",
">",
"blob",
"key",
"iterator",
"=",
"blob",
"keys",
"iterator",
"(",
")",
";",
"assert",
"true",
"(",
"blob",
"key",
"iterator",
"has",
"next",
"(",
")",
")",
";",
"blob",
"key",
"blob",
"key",
"=",
"blob",
"key",
"iterator",
"next",
"(",
")",
";",
"/",
"/",
"make",
"sure",
"that",
"all",
"blob",
"keys",
"are",
"the",
"same",
"while",
"(",
"blob",
"key",
"iterator",
"has",
"next",
"(",
")",
")",
"{",
"/",
"/",
"check",
"for",
"unique",
"blob",
"key",
",",
"but",
"should",
"have",
"same",
"hash",
"verify",
"key",
"different",
"hash",
"equals",
"(",
"blob",
"key",
",",
"blob",
"key",
"iterator",
"next",
"(",
")",
")",
";",
"}",
"/",
"/",
"check",
"the",
"uploaded",
"file",
"'",
"s",
"contents",
"verify",
"contents",
"(",
"server",
",",
"job",
"id",
",",
"blob",
"key",
",",
"data",
")",
";",
"/",
"/",
"check",
"that",
"we",
"only",
"uploaded",
"the",
"file",
"once",
"to",
"the",
"blob",
"store",
"if",
"(",
"blob",
"type",
"=",
"=",
"permanent",
"blob",
")",
"{",
"verify",
"(",
"blob",
"store",
"server",
",",
"times",
"(",
"1",
")",
")",
"put",
"(",
"any",
"(",
"file",
"class",
")",
",",
"eq",
"(",
"job",
"id",
")",
",",
"eq",
"(",
"blob",
"key",
")",
")",
";",
"}",
"else",
"{",
"/",
"/",
"can",
"'",
"t",
"really",
"verify",
"much",
"in",
"the",
"other",
"cases",
"other",
"than",
"that",
"the",
"put",
"operations",
"/",
"/",
"should",
"/",
"/",
"work",
"and",
"not",
"corrupt",
"files",
"verify",
"(",
"blob",
"store",
"server",
",",
"times",
"(",
"0",
")",
")",
"put",
"(",
"any",
"(",
"file",
"class",
")",
",",
"eq",
"(",
"job",
"id",
")",
",",
"eq",
"(",
"blob",
"key",
")",
")",
";",
"}",
"/",
"/",
"caches",
"must",
"not",
"access",
"the",
"blob",
"store",
"(",
"they",
"are",
"not",
"allowed",
"to",
"write",
"there",
")",
"verify",
"(",
"blob",
"store",
"cache",
",",
"times",
"(",
"0",
")",
")",
"put",
"(",
"any",
"(",
"file",
"class",
")",
",",
"eq",
"(",
"job",
"id",
")",
",",
"eq",
"(",
"blob",
"key",
")",
")",
";",
"}",
"finally",
"{",
"executor",
"shutdown",
"now",
"(",
")",
";",
"}",
"}"
] |
[
"the",
"lines",
"from",
"{",
"@",
"code",
"procselfcgroup",
"}",
"this",
"file",
"represents",
"the",
"control",
"groups",
"to",
"which",
"the",
"elasticsearch",
"process",
"belongs",
"each",
"line",
"in",
"this",
"file",
"represents",
"a",
"control",
"group",
"hierarchy",
"of",
"the",
"form",
"{",
"@",
"code",
"\\",
"d",
"+",
":",
"(",
"[",
"^",
":",
",",
"]",
"+",
"(",
"?",
":",
",",
"[",
"^",
":",
",",
"]",
"+",
")",
"?",
")",
":",
"(",
")",
"}",
"with",
"the",
"first",
"field",
"representing",
"the",
"hierarchy",
"id",
",",
"the",
"second",
"field",
"representing",
"a",
"comma",
"-",
"separated",
"list",
"of",
"the",
"subsystems",
"bound",
"to",
"the",
"hierarchy",
",",
"and",
"the",
"last",
"field",
"representing",
"the",
"control",
"group"
] |
[
"list",
"<",
"string",
">",
"read",
"proc",
"self",
"cgroup",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"list",
"<",
"string",
">",
"lines",
"=",
"files",
"read",
"all",
"lines",
"(",
"path",
"utils",
"get",
"(",
"\"",
"/",
"proc",
"/",
"self",
"/",
"cgroup",
"\"",
")",
")",
";",
"assert",
"lines",
"!",
"=",
"null",
"&",
"&",
"!",
"lines",
"is",
"empty",
"(",
")",
";",
"return",
"lines",
";",
"}"
] |
[
"get",
"the",
"current",
"selection"
] |
[
"byte",
"block",
"selection",
"get",
"viewer",
"selection",
"(",
")",
"{",
"field",
"selection",
"sel",
"=",
"get",
"selection",
"(",
")",
";",
"if",
"(",
"sel",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"return",
"process",
"field",
"selection",
"(",
"sel",
")",
";",
"}"
] |
[
"namespaces",
"defined",
"on",
"this",
"element",
"<",
"code",
">",
"repeated",
"aapt",
"pb",
"xml",
"namespace",
"namespace",
"declaration",
"=",
"1",
";",
"<",
"code",
">"
] |
[
"private",
"void",
"add",
"namespace",
"declaration",
"(",
"int",
"index",
",",
"com",
"android",
"aapt",
"resources",
"xml",
"namespace",
"builder",
"builder",
"for",
"value",
")",
"{",
"ensure",
"namespace",
"declaration",
"is",
"mutable",
"(",
")",
";",
"namespace",
"declaration",
"add",
"(",
"index",
",",
"builder",
"for",
"value",
"build",
"(",
")",
")",
";",
"}"
] |
[
"formats",
"the",
"checksum",
"as",
"a",
"string"
] |
[
"public",
"static",
"string",
"format",
"(",
"byte",
"[",
"]",
"checksum",
",",
"boolean",
"hex",
")",
"{",
"if",
"(",
"checksum",
"=",
"=",
"null",
"|",
"|",
"checksum",
"length",
"=",
"=",
"0",
")",
"{",
"return",
"\"",
"\"",
";",
"}",
"if",
"(",
"!",
"hex",
"&",
"&",
"checksum",
"length",
"<",
"=",
"long",
"bytes",
")",
"{",
"byte",
"buffer",
"buffy",
"=",
"byte",
"buffer",
"allocate",
"(",
"long",
"bytes",
")",
";",
"buffy",
"put",
"(",
"new",
"byte",
"[",
"long",
"bytes",
"-",
"checksum",
"length",
"]",
")",
";",
"buffy",
"put",
"(",
"checksum",
")",
";",
"buffy",
"rewind",
"(",
")",
";",
"return",
"long",
"to",
"unsigned",
"string",
"(",
"buffy",
"get",
"long",
"(",
")",
")",
";",
"}",
"return",
"numeric",
"utilities",
"convert",
"bytes",
"to",
"string",
"(",
"checksum",
")",
";",
"}"
] |
[
"sets",
"to",
"the",
"given",
"value"
] |
[
"public",
"final",
"void",
"set",
"(",
"double",
"new",
"value",
")",
"{",
"long",
"next",
"=",
"double",
"to",
"raw",
"long",
"bits",
"(",
"new",
"value",
")",
";",
"value",
"=",
"next",
";",
"}"
] |
[
"returns",
"the",
"resource",
"id"
] |
[
"public",
"short",
"get",
"i",
"d",
"(",
")",
"{",
"return",
"id",
";",
"}"
] |
[
"returns",
"true",
"if",
"the",
"array",
"is",
"empty"
] |
[
"public",
"boolean",
"is",
"empty",
"(",
")",
"{",
"return",
"elements",
"is",
"empty",
"(",
")",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"public",
"item",
"type",
"item",
"type",
"(",
")",
"{",
"return",
"item",
"type",
"type",
"map",
"item",
";",
"}"
] |
[
"extracts",
"the",
"repository",
"name",
"from",
"a",
"path",
"fragment",
"that",
"was",
"created",
"with",
"{",
"@",
"code",
"package",
"identifier",
"get",
"source",
"root",
"}"
] |
[
"public",
"static",
"pair",
"<",
"repository",
"name",
",",
"path",
"fragment",
">",
"from",
"path",
"fragment",
"(",
"path",
"fragment",
"path",
",",
"boolean",
"sibling",
"repository",
"layout",
")",
"{",
"if",
"(",
"path",
"segment",
"count",
"(",
")",
"<",
"2",
")",
"{",
"return",
"null",
";",
"}",
"path",
"fragment",
"prefix",
"=",
"sibling",
"repository",
"layout",
"?",
"label",
"constants",
"experimental",
"external",
"path",
"prefix",
":",
"label",
"constants",
"external",
"path",
"prefix",
";",
"if",
"(",
"!",
"path",
"starts",
"with",
"(",
"prefix",
")",
")",
"{",
"return",
"null",
";",
"}",
"try",
"{",
"repository",
"name",
"repo",
"name",
"=",
"repository",
"name",
"create",
"(",
"\"",
"@",
"\"",
"+",
"path",
"get",
"segment",
"(",
"1",
")",
")",
";",
"path",
"fragment",
"sub",
"path",
"=",
"path",
"sub",
"fragment",
"(",
"2",
")",
";",
"return",
"pair",
"of",
"(",
"repo",
"name",
",",
"sub",
"path",
")",
";",
"}",
"catch",
"(",
"label",
"syntax",
"exception",
"e",
")",
"{",
"return",
"null",
";",
"}",
"}"
] |
[
"bind",
"to",
"a",
"filesystem",
"instance",
"by",
"passing",
"the",
"binding",
"information",
"down",
"to",
"any",
"token",
"manager",
"which",
"implements",
"{",
"@",
"link",
"bound",
"d",
"t",
"extension",
"}",
"this",
"is",
"not",
"invoked",
"before",
"renew",
"or",
"cancel",
"operations",
",",
"but",
"is",
"guaranteed",
"to",
"be",
"invoked",
"before",
"calls",
"to",
"{",
"@",
"link",
"#",
"get",
"delegation",
"token",
"(",
"string",
")",
"}"
] |
[
"public",
"void",
"bind",
"(",
"final",
"uri",
"fs",
"u",
"r",
"i",
",",
"final",
"configuration",
"conf",
")",
"throws",
"i",
"o",
"exception",
"{",
"preconditions",
"check",
"not",
"null",
"(",
"fs",
"u",
"r",
"i",
",",
"\"",
"np",
"filesystem",
"uri",
"\"",
")",
";",
"extension",
"helper",
"bind",
"(",
"token",
"manager",
",",
"fs",
"u",
"r",
"i",
",",
"conf",
")",
";",
"}"
] |
[
"adds",
"a",
"non",
"-",
"priority",
"element",
"to",
"this",
"deque",
",",
"which",
"will",
"be",
"polled",
"last"
] |
[
"public",
"void",
"add",
"(",
"t",
"element",
")",
"{",
"deque",
"add",
"(",
"element",
")",
";",
"}"
] |
[
"get",
"the",
"cumulative",
"sum",
"of",
"all",
"buckets",
"ever",
"since",
"the",
"jvm",
"started",
"without",
"rolling",
"for",
"the",
"given",
"{",
"@",
"link",
"hystrix",
"rolling",
"number",
"event",
"}",
"type",
"see",
"{",
"@",
"link",
"#",
"get",
"rolling",
"sum",
"(",
"hystrix",
"rolling",
"number",
"event",
")",
"}",
"for",
"the",
"rolling",
"sum",
"the",
"{",
"@",
"link",
"hystrix",
"rolling",
"number",
"event",
"}",
"must",
"be",
"a",
"\"",
"counter",
"\"",
"type",
"<",
"code",
">",
"hystrix",
"rolling",
"number",
"event",
"is",
"counter",
"(",
")",
"=",
"=",
"true",
"<",
"code",
">"
] |
[
"public",
"long",
"get",
"cumulative",
"sum",
"(",
"hystrix",
"rolling",
"number",
"event",
"type",
")",
"{",
"/",
"/",
"this",
"isn",
"'",
"t",
"100",
"%",
"atomic",
"since",
"multiple",
"threads",
"can",
"be",
"affecting",
"latest",
"bucket",
"&",
"cumulative",
"sum",
"independently",
"/",
"/",
"but",
"that",
"'",
"s",
"okay",
"since",
"the",
"count",
"is",
"always",
"a",
"moving",
"target",
"and",
"we",
"'",
"re",
"accepting",
"a",
"\"",
"point",
"in",
"time",
"\"",
"best",
"attempt",
"/",
"/",
"we",
"are",
"however",
"putting",
"'",
"get",
"value",
"of",
"latest",
"bucket",
"'",
"first",
"since",
"it",
"can",
"have",
"side",
"-",
"affects",
"on",
"cumulative",
"sum",
"whereas",
"the",
"inverse",
"is",
"not",
"true",
"return",
"get",
"value",
"of",
"latest",
"bucket",
"(",
"type",
")",
"+",
"cumulative",
"sum",
"get",
"(",
"type",
")",
";",
"}"
] |
[
"resolve",
"the",
"actual",
"location",
"where",
"staged",
"data",
"should",
"be",
"written",
"this",
"might",
"point",
"at",
"an",
"asec",
"mount",
"point",
",",
"which",
"is",
"why",
"we",
"delay",
"path",
"resolution",
"until",
"someone",
"actively",
"works",
"with",
"the",
"session"
] |
[
"private",
"file",
"resolve",
"stage",
"dir",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"synchronized",
"(",
"m",
"lock",
")",
"{",
"if",
"(",
"m",
"resolved",
"stage",
"dir",
"=",
"=",
"null",
"&",
"&",
"stage",
"dir",
"!",
"=",
"null",
")",
"{",
"m",
"resolved",
"stage",
"dir",
"=",
"stage",
"dir",
";",
"if",
"(",
"!",
"stage",
"dir",
"exists",
"(",
")",
")",
"{",
"stage",
"dir",
"mkdirs",
"(",
")",
";",
"}",
"}",
"return",
"m",
"resolved",
"stage",
"dir",
";",
"}",
"}"
] |
[
"called",
"when",
"the",
"mouse",
"wheel",
"was",
"scrolled",
"will",
"not",
"be",
"called",
"on",
"i",
"o",
"s"
] |
[
"public",
"boolean",
"scrolled",
"(",
"float",
"amount",
"x",
",",
"float",
"amount",
"y",
")",
";"
] |
[
"return",
"true",
"if",
"the",
"method",
"includes",
"the",
"{",
"@",
"code",
"protected",
"}",
"modifier"
] |
[
"public",
"boolean",
"is",
"protected",
"(",
")",
"{",
"return",
"modifier",
"is",
"protected",
"(",
"method",
"get",
"modifiers",
"(",
")",
")",
";",
"}"
] |
[
"read",
"bytes",
"until",
"the",
"count",
"is",
"satisfied"
] |
[
"public",
"final",
"void",
"read",
"fully",
"(",
"byte",
"ba",
"[",
"]",
",",
"int",
"off",
",",
"int",
"len",
")",
"throws",
"i",
"o",
"exception",
"{",
"dis",
"read",
"fully",
"(",
"ba",
",",
"off",
",",
"len",
")",
";",
"}"
] |
[
"rewinds",
"and",
"clears",
"all",
"bytes"
] |
[
"private",
"void",
"clear",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"long",
"size",
";",
"try",
"(",
"file",
"input",
"stream",
"file",
"input",
"stream",
"=",
"new",
"file",
"input",
"stream",
"(",
"get",
"file",
"descriptor",
"(",
")",
")",
")",
"{",
"file",
"channel",
"channel",
"=",
"file",
"input",
"stream",
"get",
"channel",
"(",
")",
";",
"size",
"=",
"channel",
"size",
"(",
")",
";",
"if",
"(",
"size",
"=",
"=",
"0",
")",
"return",
";",
"channel",
"position",
"(",
"0",
")",
";",
"}",
"byte",
"[",
"]",
"zeros",
"=",
"new",
"byte",
"[",
"16",
"*",
"1024",
"]",
";",
"try",
"(",
"file",
"output",
"stream",
"output",
"=",
"new",
"file",
"output",
"stream",
"(",
"get",
"file",
"descriptor",
"(",
")",
")",
")",
"{",
"while",
"(",
"size",
">",
"0",
")",
"{",
"int",
"limit",
"=",
"(",
"int",
")",
"math",
"min",
"(",
"size",
",",
"zeros",
"length",
")",
";",
"output",
"write",
"(",
"zeros",
",",
"0",
",",
"limit",
")",
";",
"size",
"-",
"=",
"limit",
";",
"}",
"}",
"}"
] |
[
"removes",
"a",
"{",
"@",
"link",
"health",
"check",
"registry",
"listener",
"}",
"from",
"this",
"registry",
"'",
"s",
"collection",
"of",
"listeners"
] |
[
"public",
"void",
"remove",
"listener",
"(",
"health",
"check",
"registry",
"listener",
"listener",
")",
"{",
"listeners",
"remove",
"(",
"listener",
")",
";",
"}"
] |
[
"fires",
"the",
"{",
"@",
"link",
"#",
"on",
"started",
"(",
"run",
",",
"task",
"listener",
")",
"}",
"event"
] |
[
"public",
"static",
"void",
"fire",
"started",
"(",
"run",
"r",
",",
"task",
"listener",
"listener",
")",
"{",
"for",
"(",
"run",
"listener",
"l",
":",
"all",
"(",
")",
")",
"{",
"if",
"(",
"l",
"target",
"type",
"is",
"instance",
"(",
"r",
")",
")",
"try",
"{",
"l",
"on",
"started",
"(",
"r",
",",
"listener",
")",
";",
"}",
"catch",
"(",
"throwable",
"e",
")",
"{",
"report",
"(",
"e",
")",
";",
"}",
"}",
"}"
] |
[
"iterates",
"over",
"all",
"input",
"channels",
"and",
"collects",
"the",
"total",
"number",
"of",
"queued",
"buffers",
"in",
"a",
"best",
"-",
"effort",
"way"
] |
[
"long",
"refresh",
"and",
"get",
"total",
"(",
")",
"{",
"long",
"total",
"=",
"0",
";",
"for",
"(",
"input",
"channel",
"channel",
":",
"input",
"gate",
"get",
"input",
"channels",
"(",
")",
"values",
"(",
")",
")",
"{",
"if",
"(",
"channel",
"instanceof",
"remote",
"input",
"channel",
")",
"{",
"remote",
"input",
"channel",
"rc",
"=",
"(",
"remote",
"input",
"channel",
")",
"channel",
";",
"total",
"+",
"=",
"rc",
"unsynchronized",
"get",
"number",
"of",
"queued",
"buffers",
"(",
")",
";",
"}",
"}",
"return",
"total",
";",
"}"
] |
[
"creates",
"a",
"{",
"@",
"link",
"monitoring",
"bulk",
"request",
"}",
"with",
"the",
"given",
"number",
"of",
"{",
"@",
"link",
"monitoring",
"bulk",
"doc",
"}",
"in",
"it"
] |
[
"private",
"monitoring",
"bulk",
"request",
"random",
"request",
"(",
"final",
"int",
"num",
"docs",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"monitoring",
"bulk",
"request",
"request",
"=",
"new",
"monitoring",
"bulk",
"request",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"num",
"docs",
";",
"i",
"+",
"+",
")",
"{",
"request",
"add",
"(",
"monitoring",
"test",
"utils",
"random",
"monitoring",
"bulk",
"doc",
"(",
"random",
"(",
")",
")",
")",
";",
"}",
"return",
"request",
";",
"}"
] |
[
"model",
"tests",
"for",
"cat",
"all",
"of"
] |
[
"public",
"void",
"test",
"cat",
"all",
"of",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"cat",
"all",
"of",
"}"
] |
[
"evaluate",
"a",
"single",
"rbac",
"engine"
] |
[
"protected",
"authorization",
"decision",
"evaluate",
"engine",
"(",
"set",
"<",
"map",
"entry",
"<",
"string",
",",
"expr",
">",
">",
"entry",
"set",
",",
"authorization",
"decision",
"output",
"decision",
",",
"list",
"<",
"string",
">",
"unknown",
"policy",
"names",
",",
"activation",
"activation",
")",
"{",
"for",
"(",
"map",
"entry",
"<",
"string",
",",
"expr",
">",
"condition",
":",
"entry",
"set",
")",
"{",
"try",
"{",
"if",
"(",
"matches",
"(",
"condition",
"get",
"value",
"(",
")",
",",
"activation",
")",
")",
"{",
"return",
"new",
"authorization",
"decision",
"(",
"decision",
",",
"new",
"array",
"list",
"<",
"string",
">",
"(",
"arrays",
"as",
"list",
"(",
"new",
"string",
"[",
"]",
"{",
"condition",
"get",
"key",
"(",
")",
"}",
")",
")",
")",
";",
"}",
"}",
"catch",
"(",
"interpreter",
"exception",
"e",
")",
"{",
"unknown",
"policy",
"names",
"add",
"(",
"condition",
"get",
"key",
"(",
")",
")",
";",
"}",
"}",
"return",
"null",
";",
"}"
] |
[
"model",
"tests",
"for",
"user"
] |
[
"public",
"void",
"test",
"user",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"user",
"}"
] |
[
"decompress",
"pointer",
"data"
] |
[
"static",
"byte",
"buf",
"decompress",
"domain",
"name",
"(",
"byte",
"buf",
"compression",
")",
"{",
"string",
"domain",
"name",
"=",
"decode",
"domain",
"name",
"(",
"compression",
")",
";",
"byte",
"buf",
"result",
"=",
"compression",
"alloc",
"(",
")",
"buffer",
"(",
"domain",
"name",
"length",
"(",
")",
"<",
"<",
"1",
")",
";",
"encode",
"domain",
"name",
"(",
"domain",
"name",
",",
"result",
")",
";",
"return",
"result",
";",
"}"
] |
[
"callback",
"method",
"to",
"create",
"the",
"db",
"and",
"to",
"show",
"errors",
"if",
"they",
"happen"
] |
[
"boolean",
"create",
"new",
"data",
"type",
"archive",
"(",
")",
"{",
"data",
"type",
"archive",
"d",
"b",
"=",
"null",
";",
"domain",
"folder",
"domain",
"folder",
"=",
"get",
"domain",
"folder",
"(",
")",
";",
"string",
"archive",
"name",
"=",
"get",
"name",
"text",
"(",
")",
";",
"try",
"{",
"/",
"/",
"try",
"to",
"create",
"the",
"archive",
"to",
"make",
"sure",
"we",
"don",
"'",
"t",
"get",
"any",
"exceptions",
"data",
"type",
"archive",
"d",
"b",
"=",
"new",
"data",
"type",
"archive",
"d",
"b",
"(",
"domain",
"folder",
",",
"archive",
"name",
",",
"tool",
")",
";",
"return",
"true",
";",
"}",
"catch",
"(",
"duplicate",
"name",
"exception",
"e",
")",
"{",
"data",
"tree",
"create",
"dialog",
"set",
"status",
"text",
"(",
"\"",
"duplicate",
"name",
":",
"\"",
"+",
"e",
"get",
"message",
"(",
")",
")",
";",
"}",
"catch",
"(",
"invalid",
"name",
"exception",
"e",
")",
"{",
"data",
"tree",
"create",
"dialog",
"set",
"status",
"text",
"(",
"\"",
"invalid",
"name",
":",
"\"",
"+",
"e",
"get",
"message",
"(",
")",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"data",
"tree",
"create",
"dialog",
"set",
"status",
"text",
"(",
"\"",
"unexpected",
"i",
"o",
"exception",
"!",
"\"",
")",
";",
"msg",
"show",
"error",
"(",
"null",
",",
"data",
"tree",
"create",
"dialog",
"get",
"component",
"(",
")",
",",
"\"",
"unexpected",
"exception",
"\"",
",",
"e",
"get",
"message",
"(",
")",
",",
"e",
")",
";",
"}",
"return",
"false",
";",
"}"
] |
[
"map",
"the",
"route",
"for",
"http",
"head",
"requests"
] |
[
"public",
"static",
"void",
"head",
"(",
"string",
"path",
",",
"string",
"accept",
"type",
",",
"route",
"route",
")",
"{",
"get",
"instance",
"(",
")",
"head",
"(",
"path",
",",
"accept",
"type",
",",
"route",
")",
";",
"}"
] |
[
"remove",
"characters",
"that",
"is",
"not",
"good",
"to",
"be",
"included",
"in",
"method",
"name",
"from",
"the",
"input",
"and",
"camelize",
"it"
] |
[
"protected",
"string",
"remove",
"non",
"name",
"element",
"to",
"camel",
"case",
"(",
"final",
"string",
"name",
",",
"final",
"string",
"non",
"name",
"element",
"pattern",
")",
"{",
"string",
"result",
"=",
"arrays",
"stream",
"(",
"name",
"split",
"(",
"non",
"name",
"element",
"pattern",
")",
")",
"map",
"(",
"string",
"utils",
":",
":",
"capitalize",
")",
"collect",
"(",
"collectors",
"joining",
"(",
"\"",
"\"",
")",
")",
";",
"if",
"(",
"result",
"length",
"(",
")",
">",
"0",
")",
"{",
"result",
"=",
"result",
"substring",
"(",
"0",
",",
"1",
")",
"to",
"lower",
"case",
"(",
"locale",
"root",
")",
"+",
"result",
"substring",
"(",
"1",
")",
";",
"}",
"return",
"result",
";",
"}"
] |
[
"getter",
"for",
"the",
"{",
"@",
"link",
"federation",
"state",
"store",
"facade",
"}"
] |
[
"public",
"federation",
"state",
"store",
"facade",
"get",
"federation",
"state",
"store",
"facade",
"(",
")",
"{",
"return",
"federation",
"state",
"store",
"facade",
";",
"}"
] |
[
"copy",
"the",
"directory",
"or",
"file"
] |
[
"public",
"static",
"boolean",
"copy",
"(",
"final",
"string",
"src",
"path",
",",
"final",
"string",
"dest",
"path",
",",
"final",
"on",
"replace",
"listener",
"listener",
")",
"{",
"return",
"copy",
"(",
"get",
"file",
"by",
"path",
"(",
"src",
"path",
")",
",",
"get",
"file",
"by",
"path",
"(",
"dest",
"path",
")",
",",
"listener",
")",
";",
"}"
] |
[
"get",
"task",
"'",
"s",
"counters"
] |
[
"public",
"counters",
"get",
"counters",
"(",
")",
"{",
"return",
"counters",
";",
"}"
] |
[
"test",
"that",
"hystrix",
"owner",
"can",
"be",
"passed",
"in",
"dynamically"
] |
[
"public",
"void",
"test",
"dynamic",
"owner",
"(",
")",
"{",
"try",
"{",
"test",
"hystrix",
"observable",
"command",
"<",
"boolean",
">",
"command",
"=",
"new",
"dynamic",
"owner",
"test",
"command",
"(",
"inspectable",
"builder",
"command",
"group",
"for",
"unit",
"test",
"owner",
"one",
")",
";",
"assert",
"equals",
"(",
"true",
",",
"command",
"observe",
"(",
")",
"to",
"blocking",
"(",
")",
"single",
"(",
")",
")",
";",
"assert",
"command",
"execution",
"events",
"(",
"command",
",",
"hystrix",
"event",
"type",
"emit",
",",
"hystrix",
"event",
"type",
"success",
")",
";",
"/",
"/",
"semaphore",
"isolated",
"assert",
"false",
"(",
"command",
"is",
"executed",
"in",
"thread",
"(",
")",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"e",
"print",
"stack",
"trace",
"(",
")",
";",
"fail",
"(",
"\"",
"we",
"received",
"an",
"exception",
"\"",
")",
";",
"}",
"}"
] |
[
"merges",
"{",
"@",
"code",
"current",
"source",
"file",
"coverage",
"}",
"into",
"{",
"@",
"code",
"all",
"source",
"files",
"coverage",
"data",
"}",
"and",
"resets",
"{",
"@",
"code",
"current",
"source",
"file",
"coverage",
"}",
"to",
"null"
] |
[
"private",
"void",
"end",
"source",
"file",
"(",
")",
"{",
"if",
"(",
"current",
"source",
"file",
"coverage",
"=",
"=",
"null",
")",
"{",
"return",
";",
"}",
"record",
"branch",
"information",
"(",
"branch",
"values",
")",
";",
"all",
"source",
"files",
"add",
"(",
"current",
"source",
"file",
"coverage",
")",
";",
"current",
"source",
"file",
"coverage",
"=",
"null",
";",
"}"
] |
[
"gets",
"the",
"map",
"of",
"mergee",
"manifests",
"in",
"the",
"order",
"specified",
"on",
"the",
"command",
"line"
] |
[
"protected",
"map",
"<",
"string",
",",
"string",
">",
"get",
"mergee",
"manifests",
"(",
"artifact",
"processed",
"manifest",
")",
"throws",
"exception",
"{",
"list",
"<",
"string",
">",
"processing",
"action",
"args",
"=",
"get",
"generating",
"spawn",
"action",
"args",
"(",
"processed",
"manifest",
")",
";",
"assert",
"that",
"(",
"processing",
"action",
"args",
")",
"contains",
"(",
"\"",
"-",
"-",
"primary",
"data",
"\"",
")",
";",
"string",
"primary",
"data",
"=",
"processing",
"action",
"args",
"get",
"(",
"processing",
"action",
"args",
"index",
"of",
"(",
"\"",
"-",
"-",
"primary",
"data",
"\"",
")",
"+",
"1",
")",
";",
"string",
"merged",
"manifest",
"exec",
"path",
"string",
"=",
"splitter",
"on",
"(",
"\"",
":",
"\"",
")",
"split",
"to",
"list",
"(",
"primary",
"data",
")",
"get",
"(",
"2",
")",
";",
"spawn",
"action",
"processing",
"action",
"=",
"get",
"generating",
"spawn",
"action",
"(",
"processed",
"manifest",
")",
";",
"artifact",
"merged",
"manifest",
"=",
"iterables",
"find",
"(",
"processing",
"action",
"get",
"inputs",
"(",
")",
"to",
"list",
"(",
")",
",",
"(",
"artifact",
")",
"-",
">",
"artifact",
"get",
"exec",
"path",
"(",
")",
"to",
"string",
"(",
")",
"equals",
"(",
"merged",
"manifest",
"exec",
"path",
"string",
")",
")",
";",
"list",
"<",
"string",
">",
"merge",
"args",
"=",
"get",
"generating",
"spawn",
"action",
"args",
"(",
"merged",
"manifest",
")",
";",
"if",
"(",
"!",
"merge",
"args",
"contains",
"(",
"\"",
"-",
"-",
"mergee",
"manifests",
"\"",
")",
")",
"{",
"return",
"immutable",
"map",
"of",
"(",
")",
";",
"}",
"map",
"<",
"string",
",",
"string",
">",
"split",
"data",
"=",
"splitter",
"on",
"(",
"\"",
",",
"\"",
")",
"with",
"key",
"value",
"separator",
"(",
"splitter",
"on",
"pattern",
"(",
"\"",
"(",
"?",
"<",
"!",
"\\",
"\\",
"\\",
"\\",
")",
":",
"\"",
")",
")",
"split",
"(",
"merge",
"args",
"get",
"(",
"merge",
"args",
"index",
"of",
"(",
"\"",
"-",
"-",
"mergee",
"manifests",
"\"",
")",
"+",
"1",
")",
")",
";",
"immutable",
"map",
"builder",
"<",
"string",
",",
"string",
">",
"results",
"=",
"new",
"immutable",
"map",
"builder",
"<",
">",
"(",
")",
";",
"for",
"(",
"map",
"entry",
"<",
"string",
",",
"string",
">",
"manifest",
"and",
"label",
":",
"split",
"data",
"entry",
"set",
"(",
")",
")",
"{",
"results",
"put",
"(",
"manifest",
"and",
"label",
"get",
"key",
"(",
")",
",",
"manifest",
"and",
"label",
"get",
"value",
"(",
")",
"replace",
"(",
"\"",
"\\",
"\\",
":",
"\"",
",",
"\"",
":",
"\"",
")",
")",
";",
"}",
"return",
"results",
"build",
"(",
")",
";",
"}"
] |
[
"returns",
"the",
"total",
"number",
"of",
"checkpoints",
"(",
"in",
"progress",
",",
"completed",
",",
"failed",
")"
] |
[
"public",
"long",
"get",
"total",
"number",
"of",
"checkpoints",
"(",
")",
"{",
"return",
"num",
"total",
"checkpoints",
";",
"}"
] |
[
"return",
"headers",
"associated",
"with",
"the",
"exception",
"that",
"should",
"be",
"added",
"to",
"the",
"error",
"response",
",",
"e",
"g",
"\"",
"allow",
"\"",
",",
"\"",
"accept",
"\"",
",",
"etc",
"the",
"default",
"implementation",
"in",
"this",
"class",
"returns",
"empty",
"headers"
] |
[
"public",
"http",
"headers",
"get",
"response",
"headers",
"(",
")",
"{",
"map",
"<",
"string",
",",
"string",
">",
"headers",
"=",
"get",
"headers",
"(",
")",
";",
"if",
"(",
"headers",
"is",
"empty",
"(",
")",
")",
"{",
"return",
"http",
"headers",
"empty",
";",
"}",
"http",
"headers",
"result",
"=",
"new",
"http",
"headers",
"(",
")",
";",
"get",
"headers",
"(",
")",
"for",
"each",
"(",
"result",
":",
":",
"add",
")",
";",
"return",
"result",
";",
"}"
] |
[
"creates",
"a",
"help",
"module",
"collection",
"that",
"assumes",
"zero",
"or",
"more",
"pre",
"-",
"built",
"help",
"jar",
"files",
"and",
"one",
"help",
"directory",
"that",
"is",
"an",
"input",
"into",
"the",
"help",
"building",
"process"
] |
[
"public",
"static",
"help",
"module",
"collection",
"from",
"help",
"locations",
"(",
"collection",
"<",
"help",
"module",
"location",
">",
"locations",
")",
"{",
"return",
"new",
"help",
"module",
"collection",
"(",
"locations",
")",
";",
"}"
] |
[
"returns",
"a",
"{",
"@",
"code",
"map",
"joiner",
"}",
"using",
"the",
"given",
"key",
"-",
"value",
"separator",
",",
"and",
"the",
"same",
"configuration",
"as",
"this",
"{",
"@",
"code",
"joiner",
"}",
"otherwise"
] |
[
"public",
"map",
"joiner",
"with",
"key",
"value",
"separator",
"(",
"string",
"key",
"value",
"separator",
")",
"{",
"return",
"new",
"map",
"joiner",
"(",
"this",
",",
"key",
"value",
"separator",
")",
";",
"}"
] |
[
"converts",
"a",
"long",
"to",
"a",
"list",
"of",
"acls"
] |
[
"public",
"synchronized",
"list",
"<",
"acl",
">",
"convert",
"long",
"(",
"long",
"long",
"val",
")",
"{",
"if",
"(",
"long",
"val",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"if",
"(",
"long",
"val",
"=",
"=",
"open",
"unsafe",
"acl",
"id",
")",
"{",
"return",
"zoo",
"defs",
"ids",
"open",
"acl",
"unsafe",
";",
"}",
"list",
"<",
"acl",
">",
"acls",
"=",
"long",
"key",
"map",
"get",
"(",
"long",
"val",
")",
";",
"if",
"(",
"acls",
"=",
"=",
"null",
")",
"{",
"log",
"error",
"(",
"\"",
"error",
":",
"acl",
"not",
"available",
"for",
"long",
"{",
"}",
"\"",
",",
"long",
"val",
")",
";",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"failed",
"to",
"fetch",
"acls",
"for",
"\"",
"+",
"long",
"val",
")",
";",
"}",
"return",
"acls",
";",
"}"
] |
[
"enter",
"a",
"parse",
"tree",
"produced",
"by",
"{",
"@",
"link",
"sql",
"base",
"parser",
"#",
"function",
"expression",
"}"
] |
[
"void",
"enter",
"function",
"expression",
"(",
"sql",
"base",
"parser",
"function",
"expression",
"context",
"ctx",
")",
";"
] |
[
"convert",
"a",
"string",
"into",
"a",
"jdom",
"{",
"@",
"link",
"element",
"}"
] |
[
"public",
"static",
"element",
"from",
"string",
"(",
"string",
"s",
")",
"throws",
"j",
"d",
"o",
"m",
"exception",
",",
"i",
"o",
"exception",
"{",
"s",
"a",
"x",
"builder",
"sax",
"=",
"create",
"secure",
"s",
"a",
"x",
"builder",
"(",
"false",
",",
"false",
")",
";",
"try",
"(",
"reader",
"r",
"=",
"new",
"string",
"reader",
"(",
"s",
")",
")",
"{",
"document",
"doc",
"=",
"sax",
"build",
"(",
"r",
")",
";",
"return",
"doc",
"get",
"root",
"element",
"(",
")",
";",
"}",
"}"
] |
[
"gets",
"a",
"standardized",
"array",
"of",
"strings",
"that",
"represent",
"the",
"bookmark",
"information",
"for",
"each",
"column",
"of",
"a",
"bookmark",
"info",
"row",
"that",
"will",
"be",
"presented",
"in",
"a",
"table",
"format"
] |
[
"private",
"string",
"[",
"]",
"get",
"bookmark",
"info",
"(",
"int",
"version",
",",
"bookmark",
"bookmark",
")",
"{",
"string",
"[",
"]",
"info",
"=",
"new",
"string",
"[",
"]",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
"}",
";",
"if",
"(",
"version",
"=",
"=",
"latest",
")",
"{",
"info",
"[",
"0",
"]",
"=",
"get",
"choice",
"(",
"latest",
"title",
",",
"bookmark",
")",
";",
"}",
"else",
"if",
"(",
"version",
"=",
"=",
"my",
")",
"{",
"info",
"[",
"0",
"]",
"=",
"get",
"choice",
"(",
"my",
"title",
",",
"bookmark",
")",
";",
"}",
"else",
"if",
"(",
"version",
"=",
"=",
"original",
")",
"{",
"info",
"[",
"0",
"]",
"=",
"\"",
"'",
"\"",
"+",
"original",
"title",
"+",
"\"",
"'",
"version",
"\"",
";",
"}",
"else",
"{",
"return",
"new",
"string",
"[",
"]",
"{",
"\"",
"option",
"\"",
",",
"\"",
"type",
"\"",
",",
"\"",
"category",
"\"",
",",
"\"",
"description",
"\"",
"}",
";",
"}",
"if",
"(",
"bookmark",
"!",
"=",
"null",
")",
"{",
"info",
"[",
"1",
"]",
"=",
"bookmark",
"get",
"type",
"string",
"(",
")",
";",
"info",
"[",
"2",
"]",
"=",
"bookmark",
"get",
"category",
"(",
")",
";",
"info",
"[",
"3",
"]",
"=",
"bookmark",
"get",
"comment",
"(",
")",
";",
"}",
"return",
"info",
";",
"}"
] |
[
"enables",
"per",
"-",
"message",
"compression",
",",
"if",
"an",
"encoding",
"type",
"has",
"been",
"negotiated",
"if",
"no",
"message",
"encoding",
"has",
"been",
"negotiated",
",",
"this",
"is",
"a",
"no",
"-",
"op",
"by",
"default",
"per",
"-",
"message",
"compression",
"is",
"enabled",
",",
"but",
"may",
"not",
"have",
"any",
"effect",
"if",
"compression",
"is",
"not",
"enabled",
"on",
"the",
"call"
] |
[
"public",
"void",
"set",
"message",
"compression",
"(",
"boolean",
"enabled",
")",
"{",
"/",
"/",
"noop",
"}"
] |
[
"sets",
"{",
"@",
"link",
"option",
"u",
"d",
"t",
"#",
"protocol",
"send",
"buffer",
"size",
"}"
] |
[
"udt",
"channel",
"config",
"set",
"protocol",
"send",
"buffer",
"size",
"(",
"int",
"size",
")",
";"
] |
[
"returns",
"the",
"raw",
"type",
"of",
"{",
"@",
"code",
"t",
"}",
"formally",
"speaking",
",",
"if",
"{",
"@",
"code",
"t",
"}",
"is",
"returned",
"by",
"{",
"@",
"link",
"java",
"lang",
"reflect",
"method",
"#",
"get",
"generic",
"return",
"type",
"}",
",",
"the",
"raw",
"type",
"is",
"what",
"'",
"s",
"returned",
"by",
"{",
"@",
"link",
"java",
"lang",
"reflect",
"method",
"#",
"get",
"return",
"type",
"}",
"of",
"the",
"same",
"method",
"object",
"specifically",
":",
"if",
"{",
"@",
"code",
"t",
"}",
"is",
"a",
"{",
"@",
"code",
"class",
"}",
"itself",
",",
"{",
"@",
"code",
"t",
"}",
"itself",
"is",
"returned",
"if",
"{",
"@",
"code",
"t",
"}",
"is",
"a",
"{",
"@",
"link",
"parameterized",
"type",
"}",
",",
"the",
"raw",
"type",
"of",
"the",
"parameterized",
"type",
"is",
"returned",
"if",
"{",
"@",
"code",
"t",
"}",
"is",
"a",
"{",
"@",
"link",
"generic",
"array",
"type",
"}",
",",
"the",
"returned",
"type",
"is",
"the",
"corresponding",
"array",
"class",
"for",
"example",
":",
"{",
"@",
"code",
"list",
"<",
"integer",
">",
"[",
"]",
"=",
">",
"list",
"[",
"]",
"}",
"if",
"{",
"@",
"code",
"t",
"}",
"is",
"a",
"type",
"variable",
"or",
"a",
"wildcard",
"type",
",",
"the",
"raw",
"type",
"of",
"the",
"first",
"upper",
"bound",
"is",
"returned",
"for",
"example",
":",
"{",
"@",
"code",
"<",
"x",
"extends",
"foo",
">",
"=",
">",
"foo",
"}"
] |
[
"public",
"final",
"class",
"<",
"?",
"super",
"t",
">",
"get",
"raw",
"type",
"(",
")",
"{",
"/",
"/",
"for",
"wildcard",
"or",
"type",
"variable",
",",
"the",
"first",
"bound",
"determines",
"the",
"runtime",
"type",
"class",
"<",
"?",
">",
"raw",
"type",
"=",
"get",
"raw",
"types",
"(",
")",
"iterator",
"(",
")",
"next",
"(",
")",
";",
"@",
"suppress",
"warnings",
"(",
"\"",
"unchecked",
"\"",
")",
"/",
"/",
"raw",
"type",
"is",
"|",
"t",
"|",
"class",
"<",
"?",
"super",
"t",
">",
"result",
"=",
"(",
"class",
"<",
"?",
"super",
"t",
">",
")",
"raw",
"type",
";",
"return",
"result",
";",
"}"
] |
[
"current",
"protocol",
"configuration",
",",
"to",
"replace",
"xml",
"config",
":",
"<",
"prev",
">",
"&",
"lt",
";",
"dubbo",
":",
"protocol",
"name",
"=",
"\"",
"injvm",
"\"",
"port",
"=",
"\"",
"-",
"1",
"\"",
"&",
"gt",
";",
"<",
"prev",
">"
] |
[
"public",
"protocol",
"config",
"protocol",
"config",
"(",
")",
"{",
"protocol",
"config",
"protocol",
"config",
"=",
"new",
"protocol",
"config",
"(",
")",
";",
"protocol",
"config",
"set",
"name",
"(",
"\"",
"injvm",
"\"",
")",
";",
"protocol",
"config",
"set",
"port",
"(",
"-",
"1",
")",
";",
"return",
"protocol",
"config",
";",
"}"
] |
[
"returns",
"a",
"new",
"settings",
"object",
"that",
"contains",
"all",
"setting",
"of",
"the",
"current",
"one",
"filtered",
"by",
"the",
"given",
"settings",
"key",
"predicate"
] |
[
"public",
"settings",
"filter",
"(",
"predicate",
"<",
"string",
">",
"predicate",
")",
"{",
"return",
"new",
"settings",
"(",
"new",
"filtered",
"map",
"(",
"this",
"settings",
",",
"predicate",
",",
"null",
")",
",",
"secure",
"settings",
"=",
"=",
"null",
"?",
"null",
":",
"new",
"prefixed",
"secure",
"settings",
"(",
"secure",
"settings",
",",
"\"",
"\"",
",",
"predicate",
")",
")",
";",
"}"
] |
[
"increases",
"the",
"size",
"of",
"the",
"backing",
"arrays",
"to",
"accommodate",
"the",
"specified",
"number",
"of",
"additional",
"entries",
"useful",
"before",
"adding",
"many",
"entries",
"to",
"avoid",
"multiple",
"backing",
"array",
"resizes"
] |
[
"public",
"void",
"ensure",
"capacity",
"(",
"int",
"additional",
"capacity",
")",
"{",
"if",
"(",
"additional",
"capacity",
"<",
"0",
")",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"additional",
"capacity",
"must",
"be",
">",
"=",
"0",
":",
"\"",
"+",
"additional",
"capacity",
")",
";",
"int",
"size",
"needed",
"=",
"size",
"+",
"additional",
"capacity",
";",
"if",
"(",
"size",
"needed",
">",
"keys",
"length",
")",
"resize",
"(",
"math",
"max",
"(",
"math",
"max",
"(",
"8",
",",
"size",
"needed",
")",
",",
"(",
"int",
")",
"(",
"size",
"*",
"1",
"7",
"5f",
")",
")",
")",
";",
"}"
] |
[
"updated",
"user",
"this",
"can",
"only",
"be",
"done",
"by",
"the",
"logged",
"in",
"user",
"<",
"b",
">",
"400",
"<",
"b",
">",
"-",
"invalid",
"user",
"supplied",
"<",
"b",
">",
"404",
"<",
"b",
">",
"-",
"user",
"not",
"found"
] |
[
"public",
"response",
"entity",
"<",
"void",
">",
"update",
"user",
"with",
"http",
"info",
"(",
"string",
"username",
",",
"user",
"body",
")",
"throws",
"rest",
"client",
"exception",
"{",
"object",
"post",
"body",
"=",
"body",
";",
"/",
"/",
"verify",
"the",
"required",
"parameter",
"'",
"username",
"'",
"is",
"set",
"if",
"(",
"username",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"http",
"client",
"error",
"exception",
"(",
"http",
"status",
"bad",
"request",
",",
"\"",
"missing",
"the",
"required",
"parameter",
"'",
"username",
"'",
"when",
"calling",
"update",
"user",
"\"",
")",
";",
"}",
"/",
"/",
"verify",
"the",
"required",
"parameter",
"'",
"body",
"'",
"is",
"set",
"if",
"(",
"body",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"http",
"client",
"error",
"exception",
"(",
"http",
"status",
"bad",
"request",
",",
"\"",
"missing",
"the",
"required",
"parameter",
"'",
"body",
"'",
"when",
"calling",
"update",
"user",
"\"",
")",
";",
"}",
"/",
"/",
"create",
"path",
"and",
"map",
"variables",
"final",
"map",
"<",
"string",
",",
"object",
">",
"uri",
"variables",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"uri",
"variables",
"put",
"(",
"\"",
"username",
"\"",
",",
"username",
")",
";",
"string",
"path",
"=",
"api",
"client",
"expand",
"path",
"(",
"\"",
"/",
"user",
"/",
"{",
"username",
"}",
"\"",
",",
"uri",
"variables",
")",
";",
"final",
"multi",
"value",
"map",
"<",
"string",
",",
"string",
">",
"query",
"params",
"=",
"new",
"linked",
"multi",
"value",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"final",
"http",
"headers",
"header",
"params",
"=",
"new",
"http",
"headers",
"(",
")",
";",
"final",
"multi",
"value",
"map",
"<",
"string",
",",
"string",
">",
"cookie",
"params",
"=",
"new",
"linked",
"multi",
"value",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"final",
"multi",
"value",
"map",
"<",
"string",
",",
"object",
">",
"form",
"params",
"=",
"new",
"linked",
"multi",
"value",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"final",
"string",
"[",
"]",
"local",
"var",
"accepts",
"=",
"{",
"}",
";",
"final",
"list",
"<",
"media",
"type",
">",
"local",
"var",
"accept",
"=",
"api",
"client",
"select",
"header",
"accept",
"(",
"local",
"var",
"accepts",
")",
";",
"final",
"string",
"[",
"]",
"content",
"types",
"=",
"{",
"}",
";",
"final",
"media",
"type",
"content",
"type",
"=",
"api",
"client",
"select",
"header",
"content",
"type",
"(",
"content",
"types",
")",
";",
"string",
"[",
"]",
"auth",
"names",
"=",
"new",
"string",
"[",
"]",
"{",
"}",
";",
"parameterized",
"type",
"reference",
"<",
"void",
">",
"return",
"type",
"=",
"new",
"parameterized",
"type",
"reference",
"<",
"void",
">",
"(",
")",
"{",
"}",
";",
"return",
"api",
"client",
"invoke",
"a",
"p",
"i",
"(",
"path",
",",
"http",
"method",
"put",
",",
"query",
"params",
",",
"post",
"body",
",",
"header",
"params",
",",
"cookie",
"params",
",",
"form",
"params",
",",
"local",
"var",
"accept",
",",
"content",
"type",
",",
"auth",
"names",
",",
"return",
"type",
")",
";",
"}"
] |
[
"test",
"add",
"resource",
"set",
"=",
"null",
"with",
"add",
"resource",
"test",
"get",
"resource",
"sets"
] |
[
"public",
"void",
"test",
"add",
"resource",
"null",
"(",
")",
"{",
"hash",
"set",
"<",
"string",
">",
"resource",
"set",
"=",
"new",
"hash",
"set",
"<",
"string",
">",
"(",
")",
";",
"rpc",
"context",
"set",
"resource",
"sets",
"(",
"resource",
"set",
")",
";",
"rpc",
"context",
"add",
"resource",
"(",
"null",
")",
";",
"assertions",
"assert",
"equals",
"(",
"0",
",",
"rpc",
"context",
"get",
"resource",
"sets",
"(",
")",
"size",
"(",
")",
")",
";",
"}"
] |
[
"create",
"a",
"path",
"under",
"the",
"test",
"path",
"provided",
"by",
"the",
"fs",
"contract"
] |
[
"protected",
"path",
"path",
"(",
"string",
"filepath",
")",
"{",
"return",
"get",
"file",
"system",
"(",
")",
"make",
"qualified",
"(",
"new",
"path",
"(",
"s",
"3",
"a",
"contract",
"get",
"test",
"path",
"(",
")",
",",
"filepath",
")",
")",
";",
"}"
] |
[
"creates",
"and",
"closes",
"a",
"file",
"of",
"certain",
"length",
"calls",
"append",
"to",
"allow",
"next",
"write",
"(",
")",
"operation",
"to",
"add",
"to",
"the",
"end",
"of",
"it",
"after",
"write",
"(",
")",
"invocation",
",",
"calls",
"hflush",
"(",
")",
"to",
"make",
"sure",
"that",
"data",
"sunk",
"through",
"the",
"pipeline",
"and",
"check",
"the",
"state",
"of",
"the",
"last",
"block",
"'",
"s",
"replica",
"it",
"supposes",
"to",
"be",
"in",
"rbw",
"state"
] |
[
"public",
"void",
"pipeline",
"01",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"string",
"method",
"name",
"=",
"generic",
"test",
"utils",
"get",
"method",
"name",
"(",
")",
";",
"if",
"(",
"log",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"log",
"debug",
"(",
"\"",
"running",
"\"",
"+",
"method",
"name",
")",
";",
"}",
"path",
"file",
"path",
"=",
"new",
"path",
"(",
"\"",
"/",
"\"",
"+",
"method",
"name",
"+",
"\"",
"dat",
"\"",
")",
";",
"d",
"f",
"s",
"test",
"util",
"create",
"file",
"(",
"fs",
",",
"file",
"path",
",",
"file",
"size",
",",
"repl",
"factor",
",",
"rand",
"next",
"long",
"(",
")",
")",
";",
"if",
"(",
"log",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"log",
"debug",
"(",
"\"",
"invoking",
"append",
"but",
"doing",
"nothing",
"otherwise",
"\"",
")",
";",
"}",
"f",
"s",
"data",
"output",
"stream",
"ofs",
"=",
"fs",
"append",
"(",
"file",
"path",
")",
";",
"ofs",
"write",
"bytes",
"(",
"\"",
"some",
"more",
"stuff",
"to",
"write",
"\"",
")",
";",
"(",
"(",
"d",
"f",
"s",
"output",
"stream",
")",
"ofs",
"get",
"wrapped",
"stream",
"(",
")",
")",
"hflush",
"(",
")",
";",
"list",
"<",
"located",
"block",
">",
"lb",
"=",
"cluster",
"get",
"name",
"node",
"rpc",
"(",
")",
"get",
"block",
"locations",
"(",
"file",
"path",
"to",
"string",
"(",
")",
",",
"file",
"size",
"-",
"1",
",",
"file",
"size",
")",
"get",
"located",
"blocks",
"(",
")",
";",
"for",
"(",
"data",
"node",
"dn",
":",
"cluster",
"get",
"data",
"nodes",
"(",
")",
")",
"{",
"replica",
"r",
"=",
"cluster",
"get",
"fs",
"dataset",
"test",
"utils",
"(",
"dn",
")",
"fetch",
"replica",
"(",
"lb",
"get",
"(",
"0",
")",
"get",
"block",
"(",
")",
")",
";",
"assert",
"true",
"(",
"\"",
"replica",
"on",
"dn",
"\"",
"+",
"dn",
"+",
"\"",
"shouldn",
"'",
"t",
"be",
"null",
"\"",
",",
"r",
"!",
"=",
"null",
")",
";",
"assert",
"equals",
"(",
"\"",
"should",
"be",
"rbw",
"replica",
"on",
"\"",
"+",
"dn",
"+",
"\"",
"after",
"sequence",
"of",
"calls",
"append",
"(",
")",
"/",
"write",
"(",
")",
"/",
"hflush",
"(",
")",
"\"",
",",
"hdfs",
"server",
"constants",
"replica",
"state",
"rbw",
",",
"r",
"get",
"state",
"(",
")",
")",
";",
"}",
"ofs",
"close",
"(",
")",
";",
"}"
] |
[
"sends",
"a",
"simple",
"delete",
"request",
"to",
"the",
"given",
"path",
"you",
"only",
"specify",
"the",
"$",
"path",
"part",
"of",
"http",
":",
"$",
"host",
":",
"$",
"host",
"$",
"path"
] |
[
"public",
"void",
"send",
"delete",
"request",
"(",
"string",
"path",
",",
"duration",
"timeout",
")",
"throws",
"timeout",
"exception",
",",
"interrupted",
"exception",
"{",
"if",
"(",
"!",
"path",
"starts",
"with",
"(",
"\"",
"/",
"\"",
")",
")",
"{",
"path",
"=",
"\"",
"/",
"\"",
"+",
"path",
";",
"}",
"http",
"request",
"get",
"request",
"=",
"new",
"default",
"full",
"http",
"request",
"(",
"http",
"version",
"http",
"1",
"1",
",",
"http",
"method",
"delete",
",",
"path",
")",
";",
"get",
"request",
"headers",
"(",
")",
"set",
"(",
"http",
"headers",
"names",
"host",
",",
"host",
")",
";",
"get",
"request",
"headers",
"(",
")",
"set",
"(",
"http",
"headers",
"names",
"connection",
",",
"http",
"headers",
"values",
"close",
")",
";",
"send",
"request",
"(",
"get",
"request",
",",
"timeout",
")",
";",
"}"
] |
[
"sets",
"whether",
"the",
"notification",
"should",
"be",
"colorized",
"when",
"set",
",",
"the",
"color",
"set",
"with",
"{",
"@",
"link",
"#",
"set",
"color",
"(",
"int",
")",
"}",
"will",
"be",
"used",
"as",
"the",
"background",
"color",
"for",
"the",
"notification",
"see",
"{",
"@",
"link",
"notification",
"compat",
"builder",
"#",
"set",
"colorized",
"(",
"boolean",
")",
"}"
] |
[
"public",
"final",
"void",
"set",
"colorized",
"(",
"boolean",
"colorized",
")",
"{",
"if",
"(",
"this",
"colorized",
"!",
"=",
"colorized",
")",
"{",
"this",
"colorized",
"=",
"colorized",
";",
"invalidate",
"(",
")",
";",
"}",
"}"
] |
[
"resolves",
"the",
"specified",
"timeline",
"period",
"and",
"position",
"to",
"a",
"{",
"@",
"link",
"media",
"period",
"id",
"}",
"that",
"should",
"be",
"played",
",",
"returning",
"an",
"identifier",
"for",
"an",
"ad",
"group",
"if",
"one",
"needs",
"to",
"be",
"played",
"before",
"the",
"specified",
"position",
",",
"or",
"an",
"identifier",
"for",
"a",
"content",
"media",
"period",
"if",
"not"
] |
[
"public",
"media",
"period",
"id",
"resolve",
"media",
"period",
"id",
"for",
"ads",
"(",
"timeline",
"timeline",
",",
"object",
"period",
"uid",
",",
"long",
"position",
"us",
")",
"{",
"long",
"window",
"sequence",
"number",
"=",
"resolve",
"period",
"index",
"to",
"window",
"sequence",
"number",
"(",
"timeline",
",",
"period",
"uid",
")",
";",
"return",
"resolve",
"media",
"period",
"id",
"for",
"ads",
"(",
"timeline",
",",
"period",
"uid",
",",
"position",
"us",
",",
"window",
"sequence",
"number",
",",
"period",
")",
";",
"}"
] |
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"responding",
"server",
"is",
"authoritative",
"for",
"the",
"domain",
"name",
"in",
"the",
"query",
"message"
] |
[
"boolean",
"is",
"authoritative",
"answer",
"(",
")",
";"
] |
[
"this",
"test",
"verifies",
"some",
"assumptions",
"that",
"we",
"rely",
"upon",
"around",
"the",
"way",
"the",
"async",
"http",
"client",
"works",
"when",
"reusing",
"the",
"same",
"request",
"throughout",
"multiple",
"retries",
",",
"and",
"the",
"use",
"of",
"the",
"{",
"@",
"link",
"http",
"request",
"base",
"#",
"abort",
"(",
")",
"}",
"method",
"in",
"fact",
"the",
"low",
"-",
"level",
"rest",
"client",
"reuses",
"the",
"same",
"request",
"instance",
"throughout",
"multiple",
"retries",
",",
"and",
"relies",
"on",
"the",
"http",
"client",
"to",
"set",
"the",
"future",
"ref",
"to",
"the",
"request",
"properly",
"so",
"that",
"when",
"abort",
"is",
"called",
",",
"the",
"proper",
"future",
"gets",
"cancelled"
] |
[
"public",
"void",
"test",
"request",
"reset",
"and",
"abort",
"(",
")",
"throws",
"exception",
"{",
"try",
"(",
"closeable",
"http",
"async",
"client",
"client",
"=",
"http",
"async",
"client",
"builder",
"create",
"(",
")",
"build",
"(",
")",
")",
"{",
"client",
"start",
"(",
")",
";",
"http",
"host",
"http",
"host",
"=",
"new",
"http",
"host",
"(",
"http",
"server",
"get",
"address",
"(",
")",
"get",
"host",
"string",
"(",
")",
",",
"http",
"server",
"get",
"address",
"(",
")",
"get",
"port",
"(",
")",
")",
";",
"http",
"get",
"http",
"get",
"=",
"new",
"http",
"get",
"(",
"path",
"prefix",
"+",
"\"",
"/",
"200",
"\"",
")",
";",
"/",
"/",
"calling",
"abort",
"before",
"the",
"request",
"is",
"sent",
"is",
"a",
"no",
"-",
"op",
"http",
"get",
"abort",
"(",
")",
";",
"assert",
"true",
"(",
"http",
"get",
"is",
"aborted",
"(",
")",
")",
";",
"{",
"http",
"get",
"reset",
"(",
")",
";",
"assert",
"false",
"(",
"http",
"get",
"is",
"aborted",
"(",
")",
")",
";",
"http",
"get",
"abort",
"(",
")",
";",
"future",
"<",
"http",
"response",
">",
"future",
"=",
"client",
"execute",
"(",
"http",
"host",
",",
"http",
"get",
",",
"null",
")",
";",
"try",
"{",
"future",
"get",
"(",
")",
";",
"fail",
"(",
"\"",
"expected",
"cancellation",
"exception",
"\"",
")",
";",
"}",
"catch",
"(",
"cancellation",
"exception",
"e",
")",
"{",
"/",
"/",
"expected",
"}",
"assert",
"true",
"(",
"future",
"is",
"cancelled",
"(",
")",
")",
";",
"}",
"{",
"http",
"get",
"reset",
"(",
")",
";",
"future",
"<",
"http",
"response",
">",
"future",
"=",
"client",
"execute",
"(",
"http",
"host",
",",
"http",
"get",
",",
"null",
")",
";",
"assert",
"false",
"(",
"http",
"get",
"is",
"aborted",
"(",
")",
")",
";",
"http",
"get",
"abort",
"(",
")",
";",
"assert",
"true",
"(",
"http",
"get",
"is",
"aborted",
"(",
")",
")",
";",
"try",
"{",
"assert",
"true",
"(",
"future",
"is",
"cancelled",
"(",
")",
")",
";",
"future",
"get",
"(",
")",
";",
"throw",
"new",
"assertion",
"error",
"(",
"\"",
"exception",
"should",
"have",
"been",
"thrown",
"\"",
")",
";",
"}",
"catch",
"(",
"cancellation",
"exception",
"e",
")",
"{",
"/",
"/",
"expected",
"}",
"}",
"{",
"http",
"get",
"reset",
"(",
")",
";",
"assert",
"false",
"(",
"http",
"get",
"is",
"aborted",
"(",
")",
")",
";",
"future",
"<",
"http",
"response",
">",
"future",
"=",
"client",
"execute",
"(",
"http",
"host",
",",
"http",
"get",
",",
"null",
")",
";",
"assert",
"false",
"(",
"http",
"get",
"is",
"aborted",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"200",
",",
"future",
"get",
"(",
")",
"get",
"status",
"line",
"(",
")",
"get",
"status",
"code",
"(",
")",
")",
";",
"assert",
"false",
"(",
"future",
"is",
"cancelled",
"(",
")",
")",
";",
"}",
"}",
"}"
] |
[
"constructs",
"a",
"standard",
"{",
"@",
"code",
"enclosing",
"class",
"}",
"annotation"
] |
[
"public",
"static",
"annotation",
"make",
"enclosing",
"class",
"(",
"cst",
"type",
"clazz",
")",
"{",
"annotation",
"result",
"=",
"new",
"annotation",
"(",
"enclosing",
"class",
"type",
",",
"system",
")",
";",
"result",
"put",
"(",
"new",
"name",
"value",
"pair",
"(",
"value",
"string",
",",
"clazz",
")",
")",
";",
"result",
"set",
"immutable",
"(",
")",
";",
"return",
"result",
";",
"}"
] |
[
"creates",
"a",
"watermark",
"strategy",
"based",
"on",
"an",
"existing",
"{",
"@",
"link",
"watermark",
"generator",
"supplier",
"}"
] |
[
"static",
"<",
"t",
">",
"watermark",
"strategy",
"<",
"t",
">",
"for",
"generator",
"(",
"watermark",
"generator",
"supplier",
"<",
"t",
">",
"generator",
"supplier",
")",
"{",
"return",
"generator",
"supplier",
":",
":",
"create",
"watermark",
"generator",
";",
"}"
] |
[
"execute",
"sql",
"scripts",
"configured",
"via",
"{",
"@",
"link",
"sql",
"@",
"sql",
"}",
"for",
"the",
"supplied",
"{",
"@",
"link",
"test",
"context",
"}",
"and",
"{",
"@",
"link",
"execution",
"phase",
"}"
] |
[
"private",
"void",
"execute",
"sql",
"scripts",
"(",
"test",
"context",
"test",
"context",
",",
"execution",
"phase",
"execution",
"phase",
")",
"{",
"method",
"test",
"method",
"=",
"test",
"context",
"get",
"test",
"method",
"(",
")",
";",
"class",
"<",
"?",
">",
"test",
"class",
"=",
"test",
"context",
"get",
"test",
"class",
"(",
")",
";",
"if",
"(",
"merge",
"sql",
"annotations",
"(",
"test",
"context",
")",
")",
"{",
"execute",
"sql",
"scripts",
"(",
"get",
"sql",
"annotations",
"for",
"(",
"test",
"class",
")",
",",
"test",
"context",
",",
"execution",
"phase",
",",
"true",
")",
";",
"execute",
"sql",
"scripts",
"(",
"get",
"sql",
"annotations",
"for",
"(",
"test",
"method",
")",
",",
"test",
"context",
",",
"execution",
"phase",
",",
"false",
")",
";",
"}",
"else",
"{",
"set",
"<",
"sql",
">",
"method",
"level",
"sql",
"annotations",
"=",
"get",
"sql",
"annotations",
"for",
"(",
"test",
"method",
")",
";",
"if",
"(",
"!",
"method",
"level",
"sql",
"annotations",
"is",
"empty",
"(",
")",
")",
"{",
"execute",
"sql",
"scripts",
"(",
"method",
"level",
"sql",
"annotations",
",",
"test",
"context",
",",
"execution",
"phase",
",",
"false",
")",
";",
"}",
"else",
"{",
"execute",
"sql",
"scripts",
"(",
"get",
"sql",
"annotations",
"for",
"(",
"test",
"class",
")",
",",
"test",
"context",
",",
"execution",
"phase",
",",
"true",
")",
";",
"}",
"}",
"}"
] |
[
"solve",
"a",
"x",
"=",
"b",
",",
"where",
"b",
"is",
"a",
"column",
"vector",
"this",
"is",
"more",
"efficient",
"than",
"computing",
"the",
"inverse",
"in",
"one",
"-",
"shot",
"cases"
] |
[
"public",
"final",
"void",
"solve",
"2",
"2",
"to",
"out",
"(",
"vec",
"2",
"b",
",",
"vec",
"2",
"out",
")",
"{",
"final",
"float",
"a",
"1",
"1",
"=",
"ex",
"x",
",",
"a",
"1",
"2",
"=",
"ey",
"x",
",",
"a",
"2",
"1",
"=",
"ex",
"y",
",",
"a",
"2",
"2",
"=",
"ey",
"y",
";",
"float",
"det",
"=",
"a",
"1",
"1",
"*",
"a",
"2",
"2",
"-",
"a",
"1",
"2",
"*",
"a",
"2",
"1",
";",
"if",
"(",
"det",
"!",
"=",
"0",
"0f",
")",
"{",
"det",
"=",
"1",
"0f",
"/",
"det",
";",
"}",
"out",
"x",
"=",
"det",
"*",
"(",
"a",
"2",
"2",
"*",
"b",
"x",
"-",
"a",
"1",
"2",
"*",
"b",
"y",
")",
";",
"out",
"y",
"=",
"det",
"*",
"(",
"a",
"1",
"1",
"*",
"b",
"y",
"-",
"a",
"2",
"1",
"*",
"b",
"x",
")",
";",
"}"
] |
[
"sets",
"the",
"value",
"associated",
"with",
"this",
"{",
"@",
"link",
"context",
"register",
"info",
"}",
"object"
] |
[
"public",
"void",
"set",
"value",
"(",
"big",
"integer",
"value",
")",
"{",
"this",
"value",
"=",
"value",
";",
"}"
] |
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
] |
[
"private",
"string",
"to",
"indented",
"string",
"(",
"java",
"lang",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"remove",
"a",
"focus",
"listener"
] |
[
"public",
"void",
"remove",
"focus",
"listener",
"(",
"focus",
"listener",
"listener",
")",
"{",
"focus",
"listeners",
"remove",
"(",
"listener",
")",
";",
"}"
] |
[
"test",
"if",
"{",
"@",
"link",
"random",
"text",
"data",
"generator",
"}",
"can",
"generate",
"different",
"words",
"given",
"different",
"seeds"
] |
[
"public",
"void",
"test",
"random",
"text",
"data",
"generator",
"uniqueness",
"(",
")",
"{",
"random",
"text",
"data",
"generator",
"rtdg",
"1",
"=",
"new",
"random",
"text",
"data",
"generator",
"(",
"10",
",",
"1l",
",",
"5",
")",
";",
"set",
"<",
"string",
">",
"words",
"1",
"=",
"new",
"hash",
"set",
"(",
"rtdg",
"1",
"get",
"random",
"words",
"(",
")",
")",
";",
"random",
"text",
"data",
"generator",
"rtdg",
"2",
"=",
"new",
"random",
"text",
"data",
"generator",
"(",
"10",
",",
"0l",
",",
"5",
")",
";",
"set",
"<",
"string",
">",
"words",
"2",
"=",
"new",
"hash",
"set",
"(",
"rtdg",
"2",
"get",
"random",
"words",
"(",
")",
")",
";",
"assert",
"false",
"(",
"\"",
"list",
"size",
"mismatch",
"across",
"lists",
"\"",
",",
"words",
"1",
"equals",
"(",
"words",
"2",
")",
")",
";",
"}"
] |
[
"use",
"(",
"the",
"specified",
"slice",
"of",
"the",
"array",
"returned",
"by",
")",
"{",
"@",
"link",
"binary",
"comparable",
"#",
"get",
"bytes",
"(",
")",
"}",
"to",
"partition"
] |
[
"public",
"int",
"get",
"partition",
"(",
"binary",
"comparable",
"key",
",",
"v",
"value",
",",
"int",
"num",
"partitions",
")",
"{",
"int",
"length",
"=",
"key",
"get",
"length",
"(",
")",
";",
"int",
"left",
"index",
"=",
"(",
"left",
"offset",
"+",
"length",
")",
"%",
"length",
";",
"int",
"right",
"index",
"=",
"(",
"right",
"offset",
"+",
"length",
")",
"%",
"length",
";",
"int",
"hash",
"=",
"writable",
"comparator",
"hash",
"bytes",
"(",
"key",
"get",
"bytes",
"(",
")",
",",
"left",
"index",
",",
"right",
"index",
"-",
"left",
"index",
"+",
"1",
")",
";",
"return",
"(",
"hash",
"&",
"integer",
"max",
"value",
")",
"%",
"num",
"partitions",
";",
"}"
] |
[
"resets",
"the",
"reference",
"count",
"to",
"1"
] |
[
"public",
"final",
"void",
"reset",
"ref",
"cnt",
"(",
"t",
"instance",
")",
"{",
"updater",
"(",
")",
"set",
"(",
"instance",
",",
"initial",
"value",
"(",
")",
")",
";",
"}"
] |
[
"sets",
"the",
"minimum",
"offset",
"(",
"padding",
")",
"around",
"the",
"chart",
",",
"defaults",
"to",
"0",
"f"
] |
[
"public",
"void",
"set",
"min",
"offset",
"(",
"float",
"min",
"offset",
")",
"{",
"m",
"min",
"offset",
"=",
"min",
"offset",
";",
"}"
] |
[
"does",
"this",
"body",
"start",
"out",
"active",
"?"
] |
[
"public",
"boolean",
"is",
"active",
"(",
")",
"{",
"return",
"active",
";",
"}"
] |
[
"locates",
"the",
"keytab",
"file",
"in",
"the",
"environment",
"and",
"verifies",
"that",
"it",
"exists",
"expects",
"keytab",
"file",
"to",
"exist",
"at",
"{",
"@",
"code",
"$",
"config",
"dir",
"$",
"repository",
"-",
"hdfskrb",
"5",
"keytab",
"}"
] |
[
"static",
"path",
"locate",
"keytab",
"file",
"(",
"environment",
"environment",
")",
"{",
"path",
"keytab",
"path",
"=",
"environment",
"config",
"file",
"(",
")",
"resolve",
"(",
"\"",
"repository",
"-",
"hdfs",
"\"",
")",
"resolve",
"(",
"\"",
"krb",
"5",
"keytab",
"\"",
")",
";",
"try",
"{",
"if",
"(",
"files",
"exists",
"(",
"keytab",
"path",
")",
"=",
"=",
"false",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"could",
"not",
"locate",
"keytab",
"at",
"[",
"\"",
"+",
"keytab",
"path",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"}",
"catch",
"(",
"security",
"exception",
"se",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"could",
"not",
"locate",
"keytab",
"at",
"[",
"\"",
"+",
"keytab",
"path",
"+",
"\"",
"]",
"\"",
",",
"se",
")",
";",
"}",
"return",
"keytab",
"path",
";",
"}"
] |
[
"writes",
"{",
"@",
"code",
"value",
"}",
"as",
"an",
"unsigned",
"integer",
"to",
"{",
"@",
"code",
"out",
"}",
",",
"starting",
"at",
"{",
"@",
"code",
"offset",
"}",
"returns",
"the",
"number",
"of",
"bytes",
"written"
] |
[
"public",
"static",
"int",
"write",
"unsigned",
"leb",
"1",
"2",
"8p",
"1",
"(",
"byte",
"output",
"out",
",",
"int",
"value",
")",
"{",
"return",
"write",
"unsigned",
"leb",
"1",
"2",
"8",
"(",
"out",
",",
"value",
"+",
"1",
")",
";",
"}"
] |
[
"returns",
"whether",
"the",
"given",
"field",
"can",
"be",
"made",
"private"
] |
[
"public",
"static",
"boolean",
"can",
"be",
"made",
"private",
"(",
"field",
"field",
")",
"{",
"field",
"optimization",
"info",
"info",
"=",
"field",
"optimization",
"info",
"get",
"field",
"optimization",
"info",
"(",
"field",
")",
";",
"return",
"info",
"!",
"=",
"null",
"&",
"&",
"info",
"can",
"be",
"made",
"private",
"(",
")",
";",
"}"
] |
[
"<",
"code",
">",
"optional",
"aapt",
"pb",
"value",
"value",
"=",
"2",
";",
"<",
"code",
">"
] |
[
"private",
"void",
"clear",
"value",
"(",
")",
"{",
"value",
"=",
"null",
";",
"bit",
"field",
"0",
"=",
"(",
"bit",
"field",
"0",
"&",
"~",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"2",
")",
";",
"}"
] |
[
"write",
"a",
"{",
"@",
"linkplain",
"cursor",
"}",
"to",
"a",
"string",
"for",
"serialization",
"across",
"xcontent"
] |
[
"public",
"static",
"string",
"encode",
"to",
"string",
"(",
"cursor",
"info",
",",
"zone",
"id",
"zone",
"id",
")",
"{",
"return",
"encode",
"to",
"string",
"(",
"info",
",",
"version",
",",
"zone",
"id",
")",
";",
"}"
] |
[
"returns",
"the",
"value",
"associated",
"with",
"the",
"given",
"address"
] |
[
"public",
"field",
"get",
"value",
"(",
"address",
"addr",
")",
"{",
"lock",
"acquire",
"(",
")",
";",
"try",
"{",
"if",
"(",
"range",
"map",
"table",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"last",
"start",
"!",
"=",
"null",
"&",
"&",
"addr",
"compare",
"to",
"(",
"last",
"start",
")",
">",
"=",
"0",
"&",
"&",
"addr",
"compare",
"to",
"(",
"last",
"end",
")",
"<",
"=",
"0",
")",
"{",
"return",
"last",
"value",
";",
"}",
"try",
"{",
"long",
"index",
"=",
"addr",
"map",
"get",
"key",
"(",
"addr",
",",
"false",
")",
";",
"d",
"b",
"record",
"rec",
"=",
"range",
"map",
"table",
"get",
"record",
"at",
"or",
"before",
"(",
"index",
")",
";",
"if",
"(",
"rec",
"!",
"=",
"null",
")",
"{",
"address",
"start",
"addr",
"=",
"addr",
"map",
"decode",
"address",
"(",
"rec",
"get",
"key",
"(",
")",
")",
";",
"address",
"end",
"addr",
"=",
"addr",
"map",
"decode",
"address",
"(",
"rec",
"get",
"long",
"value",
"(",
"to",
"col",
")",
")",
";",
"if",
"(",
"addr",
"compare",
"to",
"(",
"start",
"addr",
")",
">",
"=",
"0",
"&",
"&",
"addr",
"compare",
"to",
"(",
"end",
"addr",
")",
"<",
"=",
"0",
")",
"{",
"field",
"value",
"=",
"rec",
"get",
"field",
"value",
"(",
"value",
"col",
")",
";",
"last",
"start",
"=",
"start",
"addr",
";",
"last",
"end",
"=",
"end",
"addr",
";",
"last",
"value",
"=",
"value",
";",
"last",
"range",
"=",
"new",
"address",
"range",
"impl",
"(",
"last",
"start",
",",
"last",
"end",
")",
";",
"return",
"value",
";",
"}",
"}",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"err",
"handler",
"db",
"error",
"(",
"e",
")",
";",
"}",
"}",
"return",
"null",
";",
"}",
"finally",
"{",
"lock",
"release",
"(",
")",
";",
"}",
"}"
] |
[
"sets",
"the",
"icon",
"for",
"this",
"window",
"'",
"s",
"'",
"home",
"button",
"'",
"this",
"button",
",",
"when",
"pressed",
",",
"will",
"show",
"the",
"tool",
"'",
"s",
"main",
"application",
"window"
] |
[
"public",
"void",
"set",
"home",
"button",
"(",
"icon",
"icon",
",",
"runnable",
"callback",
")",
"{",
"root",
"set",
"home",
"button",
"(",
"icon",
",",
"callback",
")",
";",
"}"
] |
[
"if",
"the",
"cluster",
"state",
"update",
"task",
"wasn",
"'",
"t",
"processed",
"by",
"the",
"provided",
"timeout",
",",
"call",
"{",
"@",
"link",
"cluster",
"state",
"task",
"listener",
"#",
"on",
"failure",
"(",
"string",
",",
"exception",
")",
"}",
"may",
"return",
"null",
"to",
"indicate",
"no",
"timeout",
"is",
"needed",
"(",
"default",
")"
] |
[
"public",
"final",
"time",
"value",
"timeout",
"(",
")",
"{",
"return",
"timeout",
";",
"}"
] |
[
"called",
"once",
"the",
"single",
"upstream",
"disposable",
"is",
"set",
"via",
"on",
"subscribe"
] |
[
"protected",
"void",
"on",
"start",
"(",
")",
"{",
"}"
] |
[
"specify",
"which",
"proxy",
"to",
"use",
"for",
"ftp",
"connections"
] |
[
"public",
"proxy",
"set",
"ftp",
"proxy",
"(",
"string",
"ftp",
"proxy",
")",
"{",
"verify",
"proxy",
"type",
"compatibility",
"(",
"proxy",
"type",
"manual",
")",
";",
"this",
"proxy",
"type",
"=",
"proxy",
"type",
"manual",
";",
"this",
"ftp",
"proxy",
"=",
"ftp",
"proxy",
";",
"return",
"this",
";",
"}"
] |
[
"returns",
"an",
"element",
"from",
"the",
"given",
"iterable",
";",
"null",
"if",
"the",
"iterable",
"is",
"null",
"or",
"empty",
"this",
"is",
"meant",
"for",
"clients",
"that",
"have",
"a",
"collection",
"with",
"any",
"number",
"of",
"items",
"and",
"just",
"need",
"to",
"get",
"one"
] |
[
"public",
"static",
"<",
"t",
">",
"t",
"any",
"(",
"iterable",
"<",
"t",
">",
"iterable",
")",
"{",
"if",
"(",
"iterable",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"iterator",
"<",
"t",
">",
"iterator",
"=",
"iterable",
"iterator",
"(",
")",
";",
"if",
"(",
"iterator",
"has",
"next",
"(",
")",
")",
"{",
"return",
"iterator",
"next",
"(",
")",
";",
"}",
"return",
"null",
";",
"}"
] |
[
"converts",
"the",
"provided",
"object",
"into",
"a",
"collection",
"and",
"return",
"the",
"first",
"element",
",",
"or",
"empty"
] |
[
"public",
"static",
"optional",
"<",
"object",
">",
"first",
"element",
"(",
"final",
"object",
"obj",
")",
"{",
"val",
"object",
"=",
"collection",
"utils",
"to",
"collection",
"(",
"obj",
")",
";",
"if",
"(",
"object",
"is",
"empty",
"(",
")",
")",
"{",
"return",
"optional",
"empty",
"(",
")",
";",
"}",
"return",
"optional",
"of",
"(",
"object",
"iterator",
"(",
")",
"next",
"(",
")",
")",
";",
"}"
] |
[
"returns",
"the",
"last",
"unstable",
"build",
",",
"if",
"any",
"otherwise",
"null"
] |
[
"public",
"run",
"t",
"get",
"last",
"unstable",
"build",
"(",
")",
"{",
"return",
"(",
"run",
"t",
")",
"permalink",
"last",
"unstable",
"build",
"resolve",
"(",
"this",
")",
";",
"}"
] |
[
"adds",
"each",
"element",
"of",
"{",
"@",
"code",
"elements",
"}",
"to",
"the",
"{",
"@",
"code",
"immutable",
"multiset",
"}"
] |
[
"public",
"builder",
"<",
"e",
">",
"add",
"all",
"(",
"iterator",
"<",
"?",
"extends",
"e",
">",
"elements",
")",
"{",
"super",
"add",
"all",
"(",
"elements",
")",
";",
"return",
"this",
";",
"}"
] |
[
"includes",
"the",
"defined",
"{",
"@",
"link",
"global",
"feature",
"}",
"to",
"the",
"newexisting",
"set",
"of",
"supported",
"features"
] |
[
"public",
"builder",
"include",
"global",
"features",
"(",
"global",
"feature",
"global",
"feature",
")",
"{",
"this",
"global",
"features",
"add",
"all",
"(",
"arrays",
"stream",
"(",
"global",
"feature",
")",
"collect",
"(",
"collectors",
"to",
"list",
"(",
")",
")",
")",
";",
"return",
"this",
";",
"}"
] |
[
"a",
"sensible",
"definition",
"of",
"{",
"@",
"link",
"#",
"higher",
"}",
"in",
"terms",
"of",
"the",
"{",
"@",
"code",
"iterator",
"}",
"method",
"of",
"{",
"@",
"link",
"#",
"tail",
"set",
"(",
"object",
",",
"boolean",
")",
"}",
"if",
"you",
"override",
"{",
"@",
"link",
"#",
"tail",
"set",
"(",
"object",
",",
"boolean",
")",
"}",
",",
"you",
"may",
"wish",
"to",
"override",
"{",
"@",
"link",
"#",
"higher",
"}",
"to",
"forward",
"to",
"this",
"implementation"
] |
[
"protected",
"e",
"standard",
"higher",
"(",
"e",
"e",
")",
"{",
"return",
"iterators",
"get",
"next",
"(",
"tail",
"set",
"(",
"e",
",",
"false",
")",
"iterator",
"(",
")",
",",
"null",
")",
";",
"}"
] |
[
"parse",
"raw",
"exec",
"properties",
"attribute",
"value",
"into",
"a",
"map",
"of",
"exec",
"group",
"names",
"to",
"their",
"properties",
"the",
"raw",
"map",
"can",
"have",
"keys",
"of",
"two",
"forms",
":",
"(",
"1",
")",
"'",
"property",
"'",
"and",
"(",
"2",
")",
"'",
"exec",
"group",
"name",
"property",
"'",
"the",
"former",
"get",
"parsed",
"into",
"the",
"target",
"'",
"s",
"default",
"exec",
"group",
",",
"the",
"latter",
"get",
"parsed",
"into",
"their",
"relevant",
"exec",
"groups"
] |
[
"private",
"static",
"immutable",
"map",
"<",
"string",
",",
"immutable",
"map",
"<",
"string",
",",
"string",
">",
">",
"parse",
"exec",
"properties",
"(",
"map",
"<",
"string",
",",
"string",
">",
"raw",
"exec",
"properties",
",",
"set",
"<",
"string",
">",
"exec",
"groups",
")",
"throws",
"invalid",
"exec",
"group",
"exception",
"{",
"map",
"<",
"string",
",",
"map",
"<",
"string",
",",
"string",
">",
">",
"consolidated",
"properties",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"consolidated",
"properties",
"put",
"(",
"default",
"exec",
"group",
"name",
",",
"new",
"hash",
"map",
"<",
">",
"(",
")",
")",
";",
"for",
"(",
"map",
"entry",
"<",
"string",
",",
"string",
">",
"exec",
"property",
":",
"raw",
"exec",
"properties",
"entry",
"set",
"(",
")",
")",
"{",
"string",
"raw",
"property",
"=",
"exec",
"property",
"get",
"key",
"(",
")",
";",
"int",
"delimiter",
"index",
"=",
"raw",
"property",
"index",
"of",
"(",
"'",
"'",
")",
";",
"if",
"(",
"delimiter",
"index",
"=",
"=",
"-",
"1",
")",
"{",
"consolidated",
"properties",
"get",
"(",
"default",
"exec",
"group",
"name",
")",
"put",
"(",
"raw",
"property",
",",
"exec",
"property",
"get",
"value",
"(",
")",
")",
";",
"}",
"else",
"{",
"string",
"exec",
"group",
"=",
"raw",
"property",
"substring",
"(",
"0",
",",
"delimiter",
"index",
")",
";",
"string",
"property",
"=",
"raw",
"property",
"substring",
"(",
"delimiter",
"index",
"+",
"1",
")",
";",
"if",
"(",
"!",
"exec",
"groups",
"contains",
"(",
"exec",
"group",
")",
")",
"{",
"throw",
"new",
"invalid",
"exec",
"group",
"exception",
"(",
"string",
"format",
"(",
"\"",
"tried",
"to",
"set",
"exec",
"property",
"'",
"%",
"s",
"'",
"for",
"non",
"-",
"existent",
"exec",
"group",
"'",
"%",
"s",
"'",
"\"",
",",
"property",
",",
"exec",
"group",
")",
")",
";",
"}",
"consolidated",
"properties",
"put",
"if",
"absent",
"(",
"exec",
"group",
",",
"new",
"hash",
"map",
"<",
">",
"(",
")",
")",
";",
"consolidated",
"properties",
"get",
"(",
"exec",
"group",
")",
"put",
"(",
"property",
",",
"exec",
"property",
"get",
"value",
"(",
")",
")",
";",
"}",
"}",
"/",
"/",
"copy",
"everything",
"to",
"immutable",
"maps",
"immutable",
"map",
"builder",
"<",
"string",
",",
"immutable",
"map",
"<",
"string",
",",
"string",
">",
">",
"exec",
"properties",
"=",
"new",
"immutable",
"map",
"builder",
"<",
">",
"(",
")",
";",
"for",
"(",
"map",
"entry",
"<",
"string",
",",
"map",
"<",
"string",
",",
"string",
">",
">",
"exec",
"group",
"map",
":",
"consolidated",
"properties",
"entry",
"set",
"(",
")",
")",
"{",
"exec",
"properties",
"put",
"(",
"exec",
"group",
"map",
"get",
"key",
"(",
")",
",",
"immutable",
"map",
"copy",
"of",
"(",
"exec",
"group",
"map",
"get",
"value",
"(",
")",
")",
")",
";",
"}",
"return",
"exec",
"properties",
"build",
"(",
")",
";",
"}"
] |
[
"the",
"weight",
"applied",
"to",
"the",
"function",
"before",
"combining"
] |
[
"public",
"final",
"float",
"get",
"weight",
"(",
")",
"{",
"return",
"weight",
";",
"}"
] |
[
"find",
"a",
"terminating",
"instruction",
"in",
"the",
"given",
"set",
"of",
"addresses",
"with",
"a",
"purge",
"encoded",
"in",
"it",
"this",
"routine",
"prefers",
"a",
"ret",
"instruction",
",",
"but",
"if",
"none",
"is",
"available",
",",
"it",
"will",
"use",
"a",
"terminating",
"call"
] |
[
"private",
"instruction",
"find",
"purge",
"instruction",
"(",
"address",
"set",
"view",
"body",
")",
"{",
"instruction",
"iterator",
"iter",
"=",
"program",
"get",
"listing",
"(",
")",
"get",
"instructions",
"(",
"body",
",",
"true",
")",
";",
"int",
"count",
"=",
"2048",
";",
"instruction",
"backup",
"purge",
"=",
"null",
";",
"while",
"(",
"iter",
"has",
"next",
"(",
")",
"&",
"&",
"count",
">",
"0",
")",
"{",
"count",
"-",
"-",
";",
"instruction",
"instr",
"=",
"iter",
"next",
"(",
")",
";",
"flow",
"type",
"ftype",
"=",
"instr",
"get",
"flow",
"type",
"(",
")",
";",
"if",
"(",
"ftype",
"is",
"terminal",
"(",
")",
")",
"{",
"if",
"(",
"instr",
"get",
"mnemonic",
"string",
"(",
")",
"compare",
"to",
"ignore",
"case",
"(",
"\"",
"ret",
"\"",
")",
"=",
"=",
"0",
")",
"{",
"return",
"instr",
";",
"}",
"else",
"if",
"(",
"ftype",
"is",
"call",
"(",
")",
")",
"{",
"backup",
"purge",
"=",
"instr",
";",
"/",
"/",
"use",
"as",
"last",
"resort",
",",
"if",
"we",
"can",
"'",
"t",
"find",
"ret",
"}",
"}",
"}",
"return",
"backup",
"purge",
";",
"}"
] |
[
"ex",
":",
"partition",
"keys",
"=",
"[",
"'",
"a",
"'",
",",
"'",
"b",
"'",
",",
"'",
"c",
"'",
"]",
"valid",
"partition",
"values",
":",
"[",
"'",
"1",
"'",
",",
"'",
"2",
"'",
",",
"'",
"3",
"'",
"]",
"or",
"[",
"'",
"'",
",",
"'",
"2",
"'",
",",
"'",
"'",
"]"
] |
[
"public",
"list",
"<",
"string",
">",
"get",
"partition",
"names",
"by",
"filter",
"(",
"string",
"database",
"name",
",",
"string",
"table",
"name",
",",
"map",
"<",
"column",
",",
"domain",
">",
"partition",
"predicates",
")",
"{",
"table",
"table",
"=",
"get",
"table",
"or",
"else",
"throw",
"(",
"database",
"name",
",",
"table",
"name",
")",
";",
"list",
"<",
"string",
">",
"parts",
"=",
"convert",
"predicate",
"to",
"parts",
"(",
"partition",
"predicates",
")",
";",
"string",
"expression",
"=",
"build",
"glue",
"expression",
"(",
"table",
"get",
"partition",
"columns",
"(",
")",
",",
"parts",
")",
";",
"list",
"<",
"partition",
">",
"partitions",
"=",
"get",
"partitions",
"(",
"database",
"name",
",",
"table",
"name",
",",
"expression",
")",
";",
"return",
"build",
"partition",
"names",
"(",
"table",
"get",
"partition",
"columns",
"(",
")",
",",
"partitions",
")",
";",
"}"
] |
[
"this",
"method",
"performs",
"an",
"asynchronous",
"ldap",
"search",
"operation",
"that",
"could",
"have",
"multiple",
"results"
] |
[
"public",
"static",
"void",
"search",
"(",
"l",
"d",
"a",
"p",
"connection",
"pool",
"ldap",
",",
"string",
"base",
"d",
"n",
",",
"search",
"scope",
"scope",
",",
"filter",
"filter",
",",
"int",
"time",
"limit",
"seconds",
",",
"boolean",
"ignore",
"referral",
"errors",
",",
"action",
"listener",
"<",
"list",
"<",
"search",
"result",
"entry",
">",
">",
"listener",
",",
"string",
"attributes",
")",
"{",
"boolean",
"searching",
"=",
"false",
";",
"l",
"d",
"a",
"p",
"connection",
"ldap",
"connection",
"=",
"null",
";",
"try",
"{",
"ldap",
"connection",
"=",
"privileged",
"connect",
"(",
"ldap",
":",
":",
"get",
"connection",
")",
";",
"final",
"l",
"d",
"a",
"p",
"connection",
"final",
"connection",
"=",
"ldap",
"connection",
";",
"search",
"(",
"final",
"connection",
",",
"base",
"d",
"n",
",",
"scope",
",",
"filter",
",",
"time",
"limit",
"seconds",
",",
"ignore",
"referral",
"errors",
",",
"action",
"listener",
"wrap",
"(",
"search",
"result",
"-",
">",
"{",
"i",
"o",
"utils",
"close",
"while",
"handling",
"exception",
"(",
"(",
")",
"-",
">",
"ldap",
"release",
"connection",
"(",
"final",
"connection",
")",
")",
";",
"listener",
"on",
"response",
"(",
"search",
"result",
")",
";",
"}",
",",
"(",
"e",
")",
"-",
">",
"{",
"i",
"o",
"utils",
"close",
"while",
"handling",
"exception",
"(",
"(",
")",
"-",
">",
"ldap",
"release",
"connection",
"(",
"final",
"connection",
")",
")",
";",
"listener",
"on",
"failure",
"(",
"e",
")",
";",
"}",
")",
",",
"attributes",
")",
";",
"searching",
"=",
"true",
";",
"}",
"catch",
"(",
"l",
"d",
"a",
"p",
"exception",
"e",
")",
"{",
"listener",
"on",
"failure",
"(",
"e",
")",
";",
"}",
"finally",
"{",
"if",
"(",
"searching",
"=",
"=",
"false",
"&",
"&",
"ldap",
"connection",
"!",
"=",
"null",
")",
"{",
"final",
"l",
"d",
"a",
"p",
"connection",
"final",
"connection",
"=",
"ldap",
"connection",
";",
"i",
"o",
"utils",
"close",
"while",
"handling",
"exception",
"(",
"(",
")",
"-",
">",
"ldap",
"release",
"connection",
"(",
"final",
"connection",
")",
")",
";",
"}",
"}",
"}"
] |
[
"clean",
"up",
"of",
"temporary",
"directories",
"created",
"by",
"the",
"{",
"@",
"link",
"cluster",
"entrypoint",
"}"
] |
[
"private",
"void",
"cleanup",
"directories",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"shutdown",
"hook",
"util",
"remove",
"shutdown",
"hook",
"(",
"shut",
"down",
"hook",
",",
"get",
"class",
"(",
")",
"get",
"simple",
"name",
"(",
")",
",",
"log",
")",
";",
"final",
"string",
"web",
"tmp",
"dir",
"=",
"configuration",
"get",
"string",
"(",
"web",
"options",
"tmp",
"dir",
")",
";",
"file",
"utils",
"delete",
"directory",
"(",
"new",
"file",
"(",
"web",
"tmp",
"dir",
")",
")",
";",
"}"
] |
[
"sets",
"the",
"{",
"@",
"link",
"output",
"path",
"mapper",
"}",
"object",
"used",
"to",
"get",
"the",
"parent",
"-",
"relative",
"paths",
"of",
"output",
"{",
"@",
"link",
"tree",
"file",
"artifact",
"}"
] |
[
"public",
"builder",
"set",
"output",
"path",
"mapper",
"(",
"output",
"path",
"mapper",
"output",
"path",
"mapper",
")",
"{",
"this",
"output",
"path",
"mapper",
"=",
"output",
"path",
"mapper",
";",
"return",
"this",
";",
"}"
] |
[
"get",
"one",
"byte",
"from",
"memory",
"at",
"the",
"current",
"position",
"plus",
"offset"
] |
[
"public",
"byte",
"get",
"byte",
"(",
"int",
"offset",
")",
"throws",
"memory",
"access",
"exception",
";"
] |
[
"animates",
"values",
"along",
"the",
"y",
"axis"
] |
[
"public",
"void",
"animate",
"y",
"(",
"int",
"duration",
"millis",
",",
"easing",
"function",
"easing",
")",
"{",
"object",
"animator",
"animator",
"y",
"=",
"y",
"animator",
"(",
"duration",
"millis",
",",
"easing",
")",
";",
"animator",
"y",
"add",
"update",
"listener",
"(",
"m",
"listener",
")",
";",
"animator",
"y",
"start",
"(",
")",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.