docstring_tokens
list | code_tokens
list |
---|---|
[
"sets",
"the",
"cursor",
"in",
"the",
"left",
"side",
"'",
"s",
"listing",
"to",
"the",
"specified",
"location"
] | [
"public",
"void",
"set",
"left",
"location",
"(",
"program",
"program",
",",
"program",
"location",
"location",
")",
"{",
"if",
"(",
"is",
"showing",
"(",
")",
")",
"{",
"go",
"to",
"left",
"location",
"(",
"location",
")",
";",
"}",
"}"
] |
[
"assemble",
"a",
"line",
"instruction",
"at",
"the",
"given",
"address",
"this",
"method",
"is",
"valid",
"with",
"or",
"without",
"a",
"bound",
"program",
"even",
"if",
"bound",
",",
"the",
"program",
"is",
"not",
"modified",
";",
"however",
",",
"the",
"appropriate",
"context",
"information",
"is",
"taken",
"from",
"the",
"bound",
"program",
"without",
"a",
"program",
",",
"the",
"language",
"'",
"s",
"default",
"context",
"is",
"taken",
"at",
"the",
"given",
"location"
] | [
"public",
"byte",
"[",
"]",
"assemble",
"line",
"(",
"address",
"at",
",",
"string",
"line",
")",
"throws",
"assembly",
"syntax",
"exception",
",",
"assembly",
"semantic",
"exception",
";"
] |
[
"read",
"from",
"the",
"input",
"stream",
"into",
"the",
"given",
"text"
] | [
"public",
"int",
"read",
"line",
"(",
"text",
"str",
",",
"int",
"max",
"line",
"length",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"read",
"line",
"(",
"str",
",",
"max",
"line",
"length",
",",
"integer",
"max",
"value",
")",
";",
"}"
] |
[
"a",
"convenience",
"method",
"for",
"getting",
"a",
"{",
"@",
"link",
"graph",
"display",
"}",
"from",
"the",
"currently",
"active",
"provider"
] | [
"public",
"graph",
"display",
"get",
"default",
"graph",
"display",
"(",
"boolean",
"reuse",
"graph",
",",
"task",
"monitor",
"monitor",
")",
"throws",
"graph",
"exception",
";"
] |
[
"test",
"the",
"property",
"'",
"ship",
"date",
"'"
] | [
"public",
"void",
"ship",
"date",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"ship",
"date",
"}"
] |
[
"test",
"that",
"{",
"@",
"link",
"read",
"only",
"engine",
"#",
"verify",
"engine",
"before",
"index",
"closing",
"(",
")",
"}",
"never",
"fails",
"whatever",
"the",
"value",
"of",
"the",
"global",
"checkpoint",
"to",
"check",
"is"
] | [
"public",
"void",
"test",
"verify",
"shard",
"before",
"index",
"closing",
"is",
"no",
"op",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"i",
"o",
"utils",
"close",
"(",
"engine",
",",
"store",
")",
";",
"final",
"atomic",
"long",
"global",
"checkpoint",
"=",
"new",
"atomic",
"long",
"(",
"sequence",
"numbers",
"no",
"ops",
"performed",
")",
";",
"try",
"(",
"store",
"store",
"=",
"create",
"store",
"(",
")",
")",
"{",
"engine",
"config",
"config",
"=",
"config",
"(",
"default",
"settings",
",",
"store",
",",
"create",
"temp",
"dir",
"(",
")",
",",
"new",
"merge",
"policy",
"(",
")",
",",
"null",
",",
"null",
",",
"global",
"checkpoint",
":",
":",
"get",
")",
";",
"store",
"create",
"empty",
"(",
")",
";",
"try",
"(",
"read",
"only",
"engine",
"read",
"only",
"engine",
"=",
"new",
"read",
"only",
"engine",
"(",
"config",
",",
"null",
",",
"new",
"translog",
"stats",
"(",
")",
",",
"true",
",",
"function",
"identity",
"(",
")",
",",
"true",
")",
")",
"{",
"global",
"checkpoint",
"set",
"(",
"random",
"non",
"negative",
"long",
"(",
")",
")",
";",
"try",
"{",
"read",
"only",
"engine",
"verify",
"engine",
"before",
"index",
"closing",
"(",
")",
";",
"}",
"catch",
"(",
"final",
"illegal",
"state",
"exception",
"e",
")",
"{",
"fail",
"(",
"\"",
"read",
"-",
"only",
"engine",
"pre",
"-",
"closing",
"verifications",
"failed",
"\"",
")",
";",
"}",
"}",
"}",
"}"
] |
[
"return",
"the",
"configured",
"return",
"value",
"handlers"
] | [
"public",
"return",
"value",
"handler",
"configurer",
"get",
"return",
"value",
"handler",
"configurer",
"(",
")",
"{",
"return",
"this",
"return",
"value",
"handler",
"configurer",
";",
"}"
] |
[
"links",
"a",
"{",
"@",
"link",
"dynamic",
"value",
"}",
"object",
"ot",
"the",
"alpha",
"value",
"for",
"this",
"component"
] | [
"public",
"t",
"alpha",
"(",
"dynamic",
"value",
"<",
"float",
">",
"value",
")",
"{",
"m",
"component",
"get",
"or",
"create",
"common",
"dynamic",
"props",
"(",
")",
"put",
"(",
"key",
"alpha",
",",
"value",
")",
";",
"return",
"get",
"this",
"(",
")",
";",
"}"
] |
[
"returns",
"a",
"comparator",
"for",
"symbols",
"the",
"comparison",
"is",
"based",
"upon",
"the",
"name",
"this",
"call",
"replaces",
"the",
"former",
"<",
"code",
">",
"compare",
"to",
"<",
"code",
">",
"method",
"on",
"symbol",
"this",
"comparator",
"returned",
"here",
"is",
"case",
"-",
"insensitive"
] | [
"public",
"static",
"comparator",
"<",
"symbol",
">",
"get",
"symbol",
"name",
"comparator",
"(",
")",
"{",
"return",
"case",
"insensitive",
"symbol",
"name",
"comparator",
";",
"}"
] |
[
"updates",
"the",
"range",
"of",
"items",
"starting",
"at",
"position",
"the",
"{",
"@",
"link",
"recycler",
"view",
"}",
"gets",
"notified",
"immediately",
"about",
"the",
"item",
"being",
"updated"
] | [
"public",
"final",
"void",
"update",
"range",
"at",
"(",
"int",
"position",
",",
"list",
"<",
"render",
"info",
">",
"render",
"infos",
")",
"{",
"thread",
"utils",
"assert",
"main",
"thread",
"(",
")",
";",
"if",
"(",
"sections",
"debug",
"enabled",
")",
"{",
"final",
"string",
"[",
"]",
"names",
"=",
"new",
"string",
"[",
"render",
"infos",
"size",
"(",
")",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"render",
"infos",
"size",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"names",
"[",
"i",
"]",
"=",
"render",
"infos",
"get",
"(",
"i",
")",
"get",
"name",
"(",
")",
";",
"}",
"log",
"d",
"(",
"sections",
"debug",
"tag",
",",
"\"",
"(",
"\"",
"+",
"hash",
"code",
"(",
")",
"+",
"\"",
")",
"update",
"range",
"at",
"\"",
"+",
"position",
"+",
"\"",
",",
"size",
":",
"\"",
"+",
"render",
"infos",
"size",
"(",
")",
"+",
"\"",
",",
"names",
":",
"\"",
"+",
"arrays",
"to",
"string",
"(",
"names",
")",
")",
";",
"}",
"synchronized",
"(",
"this",
")",
"{",
"try",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
",",
"size",
"=",
"render",
"infos",
"size",
"(",
")",
";",
"i",
"<",
"size",
";",
"i",
"+",
"+",
")",
"{",
"final",
"component",
"tree",
"holder",
"holder",
"=",
"m",
"component",
"tree",
"holders",
"get",
"(",
"position",
"+",
"i",
")",
";",
"final",
"render",
"info",
"new",
"render",
"info",
"=",
"render",
"infos",
"get",
"(",
"i",
")",
";",
"assert",
"not",
"null",
"render",
"info",
"(",
"new",
"render",
"info",
")",
";",
"/",
"/",
"if",
"this",
"item",
"is",
"rendered",
"with",
"a",
"view",
"(",
"or",
"was",
"rendered",
"with",
"a",
"view",
"before",
"now",
")",
"we",
"still",
"/",
"/",
"need",
"to",
"notify",
"the",
"recycler",
"view",
"'",
"s",
"adapter",
"that",
"something",
"changed",
"if",
"(",
"new",
"render",
"info",
"renders",
"view",
"(",
")",
"|",
"|",
"holder",
"get",
"render",
"info",
"(",
")",
"renders",
"view",
"(",
")",
")",
"{",
"m",
"internal",
"adapter",
"notify",
"item",
"changed",
"(",
"position",
"+",
"i",
")",
";",
"}",
"m",
"render",
"info",
"view",
"creator",
"controller",
"maybe",
"track",
"view",
"creator",
"(",
"new",
"render",
"info",
")",
";",
"update",
"holder",
"(",
"holder",
",",
"new",
"render",
"info",
")",
";",
"}",
"}",
"catch",
"(",
"index",
"out",
"of",
"bounds",
"exception",
"e",
")",
"{",
"final",
"string",
"[",
"]",
"names",
"=",
"new",
"string",
"[",
"render",
"infos",
"size",
"(",
")",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"render",
"infos",
"size",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"names",
"[",
"i",
"]",
"=",
"render",
"infos",
"get",
"(",
"i",
")",
"get",
"name",
"(",
")",
";",
"}",
"string",
"debug",
"info",
"=",
"\"",
"(",
"\"",
"+",
"hash",
"code",
"(",
")",
"+",
"\"",
")",
"update",
"range",
"at",
"\"",
"+",
"position",
"+",
"\"",
",",
"size",
":",
"\"",
"+",
"render",
"infos",
"size",
"(",
")",
"+",
"\"",
",",
"names",
":",
"\"",
"+",
"arrays",
"to",
"string",
"(",
"names",
")",
";",
"throw",
"new",
"index",
"out",
"of",
"bounds",
"exception",
"(",
"debug",
"info",
"+",
"e",
"get",
"message",
"(",
")",
")",
";",
"}",
"}",
"m",
"viewport",
"manager",
"set",
"should",
"update",
"(",
"m",
"viewport",
"manager",
"update",
"affects",
"visible",
"range",
"(",
"position",
",",
"render",
"infos",
"size",
"(",
")",
")",
")",
";",
"}"
] |
[
"peeks",
"at",
"the",
"next",
"long",
"without",
"incrementing",
"the",
"current",
"index"
] | [
"public",
"long",
"peek",
"next",
"long",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"read",
"long",
"(",
"current",
"index",
")",
";",
"}"
] |
[
"clear",
"unique",
"storage",
"at",
"the",
"start",
"of",
"an",
"instruction"
] | [
"public",
"void",
"clear",
"(",
")",
"{",
"map",
"clear",
"(",
")",
";",
"}"
] |
[
"returns",
"the",
"number",
"of",
"bytes",
"the",
"modified",
"utf8",
"representation",
"of",
"'",
"s",
"'",
"would",
"take"
] | [
"private",
"static",
"long",
"count",
"bytes",
"(",
"string",
"s",
",",
"boolean",
"short",
"length",
")",
"throws",
"u",
"t",
"f",
"data",
"format",
"exception",
"{",
"long",
"result",
"=",
"0",
";",
"final",
"int",
"length",
"=",
"s",
"length",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"length",
";",
"+",
"+",
"i",
")",
"{",
"char",
"ch",
"=",
"s",
"char",
"at",
"(",
"i",
")",
";",
"if",
"(",
"ch",
"!",
"=",
"0",
"&",
"&",
"ch",
"<",
"=",
"127",
")",
"{",
"/",
"/",
"u",
"+",
"0000",
"uses",
"two",
"bytes",
"+",
"+",
"result",
";",
"}",
"else",
"if",
"(",
"ch",
"<",
"=",
"2047",
")",
"{",
"result",
"+",
"=",
"2",
";",
"}",
"else",
"{",
"result",
"+",
"=",
"3",
";",
"}",
"if",
"(",
"short",
"length",
"&",
"&",
"result",
">",
"65535",
")",
"{",
"throw",
"new",
"u",
"t",
"f",
"data",
"format",
"exception",
"(",
"\"",
"string",
"more",
"than",
"65535",
"utf",
"bytes",
"long",
"\"",
")",
";",
"}",
"}",
"return",
"result",
";",
"}"
] |
[
"remove",
"all",
"items",
"from",
"cache"
] | [
"void",
"clear",
"(",
")",
";"
] |
[
"get",
"the",
"trigger",
"id",
"for",
"the",
"given",
"operation",
"key"
] | [
"public",
"trigger",
"id",
"get",
"trigger",
"id",
"(",
")",
"{",
"return",
"trigger",
"id",
";",
"}"
] |
[
"write",
"a",
"double",
"to",
"the",
"specified",
"index",
"of",
"this",
"buffer",
"and",
"the",
"position",
"is",
"not",
"changed"
] | [
"public",
"abstract",
"double",
"buffer",
"put",
"(",
"int",
"index",
",",
"double",
"d",
")",
";"
] |
[
"sets",
"the",
"{",
"@",
"link",
"channel",
"factory",
"}",
"as",
"a",
"{",
"@",
"link",
"reflective",
"channel",
"factory",
"}",
"of",
"this",
"type",
"use",
"as",
"an",
"alternative",
"to",
"{",
"@",
"link",
"#",
"channel",
"factory",
"(",
"channel",
"factory",
")",
"}"
] | [
"public",
"dns",
"name",
"resolver",
"builder",
"channel",
"type",
"(",
"class",
"<",
"?",
"extends",
"datagram",
"channel",
">",
"channel",
"type",
")",
"{",
"return",
"channel",
"factory",
"(",
"new",
"reflective",
"channel",
"factory",
"<",
"datagram",
"channel",
">",
"(",
"channel",
"type",
")",
")",
";",
"}"
] |
[
"return",
"the",
"url",
"to",
"which",
"the",
"leader",
"accepts",
"requests",
"from",
"other",
"members",
"of",
"the",
"group"
] | [
"public",
"string",
"leader",
"url",
"(",
")",
"{",
"return",
"leader",
"url",
";",
"}"
] |
[
"sends",
"out",
"a",
"string",
"error",
"message",
"that",
"indicates",
"an",
"error"
] | [
"public",
"static",
"form",
"fill",
"failure",
"error",
"(",
"@",
"non",
"null",
"string",
"message",
")",
"{",
"return",
"error",
"with",
"markup",
"(",
"util",
"escape",
"(",
"message",
")",
")",
";",
"}"
] |
[
"get",
"the",
"composite",
"caret",
"location"
] | [
"public",
"int",
"get",
"global",
"caret",
"(",
")",
"{",
"return",
"get",
"global",
"caret",
"(",
"-",
"1",
")",
";",
"}"
] |
[
"special",
"case",
"method",
"to",
"bind",
"to",
"a",
"dynamic",
"value",
"<",
"integer",
">",
"to",
"animate",
"color"
] | [
"public",
"void",
"to",
"integer",
"(",
"state",
"value",
"<",
"dynamic",
"value",
"<",
"integer",
">",
">",
"dynamic",
"value",
"state",
")",
"{",
"dynamic",
"value",
"<",
"integer",
">",
"dynamic",
"value",
"=",
"create",
"integer",
"(",
")",
";",
"dynamic",
"value",
"state",
"set",
"(",
"dynamic",
"value",
")",
";",
"}"
] |
[
"set",
"whether",
"to",
"only",
"include",
"advisors",
"with",
"a",
"certain",
"prefix",
"in",
"the",
"bean",
"name",
"default",
"is",
"{",
"@",
"code",
"false",
"}",
",",
"including",
"all",
"beans",
"of",
"type",
"{",
"@",
"code",
"advisor",
"}"
] | [
"public",
"void",
"set",
"use",
"prefix",
"(",
"boolean",
"use",
"prefix",
")",
"{",
"this",
"use",
"prefix",
"=",
"use",
"prefix",
";",
"}"
] |
[
"returns",
"the",
"currently",
"opened",
"class",
"node",
",",
"if",
"nothing",
"is",
"opened",
"it",
"'",
"ll",
"return",
"null"
] | [
"public",
"static",
"class",
"node",
"get",
"currently",
"opened",
"class",
"node",
"(",
")",
"{",
"return",
"the",
"bytecode",
"club",
"bytecodeviewer",
"bytecode",
"viewer",
"get",
"currently",
"opened",
"class",
"node",
"(",
")",
";",
"}"
] |
[
"get",
"the",
"thread",
"pool",
"for",
"executing",
"the",
"single",
"file",
"commitrevert",
"within",
"the",
"commit",
"of",
"all",
"uploads",
"of",
"a",
"single",
"task",
"this",
"is",
"currently",
"null",
";",
"it",
"is",
"here",
"to",
"allow",
"the",
"tasks",
"class",
"to",
"provide",
"the",
"logic",
"for",
"executerevert"
] | [
"protected",
"final",
"synchronized",
"tasks",
"submitter",
"single",
"thread",
"submitter",
"(",
")",
"{",
"return",
"null",
";",
"}"
] |
[
"group",
"a",
"list",
"of",
"partitions",
"by",
"the",
"topic",
"name"
] | [
"public",
"static",
"map",
"<",
"string",
",",
"list",
"<",
"integer",
">",
">",
"group",
"partitions",
"by",
"topic",
"(",
"collection",
"<",
"topic",
"partition",
">",
"partitions",
")",
"{",
"map",
"<",
"string",
",",
"list",
"<",
"integer",
">",
">",
"partitions",
"by",
"topic",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"for",
"(",
"topic",
"partition",
"tp",
":",
"partitions",
")",
"{",
"string",
"topic",
"=",
"tp",
"topic",
"(",
")",
";",
"list",
"<",
"integer",
">",
"topic",
"data",
"=",
"partitions",
"by",
"topic",
"compute",
"if",
"absent",
"(",
"topic",
",",
"t",
"-",
">",
"new",
"array",
"list",
"<",
">",
"(",
")",
")",
";",
"topic",
"data",
"add",
"(",
"tp",
"partition",
"(",
")",
")",
";",
"}",
"return",
"partitions",
"by",
"topic",
";",
"}"
] |
[
"the",
"entry",
"point",
"of",
"application"
] | [
"public",
"static",
"void",
"main",
"(",
"string",
"[",
"]",
"args",
")",
"{",
"netty",
"remoting",
"server",
"netty",
"server",
"=",
"new",
"netty",
"remoting",
"server",
"(",
"working",
"threads",
")",
";",
"netty",
"server",
"set",
"handler",
"(",
"new",
"default",
"coordinator",
"(",
"netty",
"server",
")",
")",
";",
"u",
"u",
"i",
"d",
"generator",
"init",
"(",
"1l",
")",
";",
"xid",
"set",
"ip",
"address",
"(",
"net",
"util",
"get",
"local",
"ip",
"(",
")",
")",
";",
"xid",
"set",
"port",
"(",
"netty",
"server",
"get",
"listen",
"port",
"(",
")",
")",
";",
"netty",
"server",
"init",
"(",
")",
";",
"system",
"exit",
"(",
"0",
")",
";",
"}"
] |
[
"get",
"the",
"current",
"generation",
"state",
"if",
"the",
"group",
"is",
"stable",
",",
"otherwise",
"return",
"null"
] | [
"protected",
"synchronized",
"generation",
"generation",
"if",
"stable",
"(",
")",
"{",
"if",
"(",
"this",
"state",
"!",
"=",
"member",
"state",
"stable",
")",
"return",
"null",
";",
"return",
"generation",
";",
"}"
] |
[
"manipulate",
"this",
"entity",
"'",
"s",
"headers",
"with",
"the",
"given",
"consumer",
"the",
"headers",
"provided",
"to",
"the",
"consumer",
"are",
"\"",
"live",
"\"",
",",
"so",
"that",
"the",
"consumer",
"can",
"be",
"used",
"to",
"{",
"@",
"linkplain",
"http",
"headers",
"#",
"set",
"(",
"string",
",",
"string",
")",
"overwrite",
"}",
"existing",
"header",
"values",
",",
"{",
"@",
"linkplain",
"http",
"headers",
"#",
"remove",
"(",
"object",
")",
"remove",
"}",
"values",
",",
"or",
"use",
"any",
"of",
"the",
"other",
"{",
"@",
"link",
"http",
"headers",
"}",
"methods"
] | [
"b",
"headers",
"(",
"consumer",
"<",
"http",
"headers",
">",
"headers",
"consumer",
")",
";"
] |
[
"constructor",
"arguments",
"are",
"detected",
"by",
"this",
"\"",
"marker",
"\"",
"consumer",
"it",
"keeps",
"the",
"api",
"looking",
"clean",
"even",
"if",
"it",
"is",
"a",
"bit",
"sleezy"
] | [
"private",
"boolean",
"is",
"constructor",
"arg",
"(",
"bi",
"consumer",
"<",
"?",
",",
"?",
">",
"consumer",
")",
"{",
"return",
"consumer",
"=",
"=",
"required",
"constructor",
"arg",
"marker",
"|",
"|",
"consumer",
"=",
"=",
"optional",
"constructor",
"arg",
"marker",
";",
"}"
] |
[
"asynchronous",
"decoding",
"is",
"not",
"supported"
] | [
"public",
"boolean",
"async",
"decode",
"(",
"final",
"cached",
"data",
"d",
")",
"{",
"return",
"false",
";",
"}"
] |
[
"removes",
"all",
"addresses",
"from",
"the",
"set"
] | [
"public",
"void",
"clear",
"(",
")",
"{",
"rb",
"tree",
"remove",
"all",
"(",
")",
";",
"last",
"node",
"=",
"null",
";",
"address",
"count",
"=",
"0",
";",
"}"
] |
[
"specifies",
"the",
"expected",
"number",
"of",
"nodes",
"in",
"the",
"network"
] | [
"public",
"network",
"builder",
"<",
"n",
",",
"e",
">",
"expected",
"node",
"count",
"(",
"int",
"expected",
"node",
"count",
")",
"{",
"this",
"expected",
"node",
"count",
"=",
"optional",
"of",
"(",
"check",
"non",
"negative",
"(",
"expected",
"node",
"count",
")",
")",
";",
"return",
"this",
";",
"}"
] |
[
"if",
"not",
"set",
"the",
"input",
"data",
"is",
"assumed",
"to",
"be",
"csv",
"with",
"a",
"'",
"time",
"'",
"field",
"in",
"epoch",
"format"
] | [
"public",
"data",
"description",
"get",
"data",
"description",
"(",
")",
"{",
"return",
"data",
"description",
";",
"}"
] |
[
"return",
"{",
"@",
"code",
"false",
"}",
"if",
"resource",
"mappings",
"were",
"manually",
"configured",
",",
"{",
"@",
"code",
"true",
"}",
"otherwise"
] | [
"public",
"boolean",
"is",
"autodetect",
"(",
")",
"{",
"return",
"this",
"autodetect",
";",
"}"
] |
[
"write",
"a",
"suffix",
"after",
"the",
"main",
"content"
] | [
"protected",
"void",
"write",
"suffix",
"(",
"json",
"generator",
"generator",
",",
"object",
"object",
")",
"throws",
"i",
"o",
"exception",
"{",
"}"
] |
[
"remove",
"a",
"listener",
"added",
"with",
"{",
"@",
"link",
"#",
"add",
"model",
"build",
"listener",
"(",
"on",
"model",
"build",
"finished",
"listener",
")",
"}",
"this",
"is",
"safe",
"to",
"call",
"from",
"inside",
"the",
"callback",
"{",
"@",
"link",
"on",
"model",
"build",
"finished",
"listener",
"#",
"on",
"model",
"build",
"finished",
"(",
"diff",
"result",
")",
"}"
] | [
"public",
"void",
"remove",
"model",
"build",
"listener",
"(",
"on",
"model",
"build",
"finished",
"listener",
"listener",
")",
"{",
"adapter",
"remove",
"model",
"build",
"listener",
"(",
"listener",
")",
";",
"}"
] |
[
"return",
"all",
"data",
"flavors",
"that",
"this",
"class",
"supports"
] | [
"public",
"synchronized",
"data",
"flavor",
"[",
"]",
"get",
"transfer",
"data",
"flavors",
"(",
")",
"{",
"return",
"flavors",
";",
"}"
] |
[
"get",
"photo",
"urls"
] | [
"public",
"list",
"<",
"string",
">",
"get",
"photo",
"urls",
"(",
")",
"{",
"return",
"photo",
"urls",
";",
"}"
] |
[
"converts",
"{",
"@",
"link",
"i",
"o",
"exception",
"}",
"on",
"body",
"reading",
"to",
"{",
"@",
"link",
"push",
"network",
"exception",
"}",
"{",
"@",
"link",
"i",
"o",
"exception",
"}",
"during",
"json",
"parsing",
"is",
"converted",
"to",
"a",
"{",
"@",
"link",
"non",
"successful",
"response",
"code",
"exception",
"}"
] | [
"private",
"static",
"<",
"t",
">",
"t",
"read",
"body",
"json",
"(",
"response",
"body",
"body",
",",
"class",
"<",
"t",
">",
"clazz",
")",
"throws",
"push",
"network",
"exception",
",",
"non",
"successful",
"response",
"code",
"exception",
"{",
"string",
"json",
"=",
"read",
"body",
"string",
"(",
"body",
")",
";",
"try",
"{",
"return",
"json",
"util",
"from",
"json",
"(",
"json",
",",
"clazz",
")",
";",
"}",
"catch",
"(",
"json",
"processing",
"exception",
"e",
")",
"{",
"log",
"w",
"(",
"tag",
",",
"e",
")",
";",
"throw",
"new",
"non",
"successful",
"response",
"code",
"exception",
"(",
"\"",
"unable",
"to",
"parse",
"entity",
"\"",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"throw",
"new",
"push",
"network",
"exception",
"(",
"e",
")",
";",
"}",
"}"
] |
[
"creates",
"a",
"new",
"out",
"err",
"instance",
"from",
"the",
"specified",
"stream",
"writes",
"to",
"either",
"the",
"output",
"or",
"err",
"of",
"the",
"new",
"out",
"err",
"are",
"written",
"to",
"output",
"stream",
",",
"synchronized"
] | [
"public",
"static",
"out",
"err",
"create",
"synchronized",
"funnel",
"(",
"final",
"output",
"stream",
"output",
"stream",
")",
"{",
"output",
"stream",
"sync",
"out",
"=",
"new",
"output",
"stream",
"(",
")",
"{",
"@",
"override",
"public",
"synchronized",
"void",
"write",
"(",
"int",
"b",
")",
"throws",
"i",
"o",
"exception",
"{",
"output",
"stream",
"write",
"(",
"b",
")",
";",
"}",
"@",
"override",
"public",
"synchronized",
"void",
"write",
"(",
"byte",
"[",
"]",
"b",
")",
"throws",
"i",
"o",
"exception",
"{",
"output",
"stream",
"write",
"(",
"b",
")",
";",
"}",
"@",
"override",
"public",
"synchronized",
"void",
"write",
"(",
"byte",
"[",
"]",
"b",
",",
"int",
"off",
",",
"int",
"len",
")",
"throws",
"i",
"o",
"exception",
"{",
"output",
"stream",
"write",
"(",
"b",
",",
"off",
",",
"len",
")",
";",
"}",
"@",
"override",
"public",
"synchronized",
"void",
"flush",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"output",
"stream",
"flush",
"(",
")",
";",
"}",
"@",
"override",
"public",
"synchronized",
"void",
"close",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"output",
"stream",
"close",
"(",
")",
";",
"}",
"}",
";",
"return",
"create",
"(",
"sync",
"out",
",",
"sync",
"out",
")",
";",
"}"
] |
[
"find",
"the",
"indices",
"of",
"<",
"code",
">",
"target",
"cols",
"<",
"code",
">",
"in",
"string",
"array",
"<",
"code",
">",
"table",
"cols",
"<",
"code",
">",
"if",
"<",
"code",
">",
"target",
"cols",
"<",
"code",
">",
"is",
"null",
",",
"it",
"will",
"be",
"replaced",
"by",
"the",
"<",
"code",
">",
"table",
"cols",
"<",
"code",
">"
] | [
"public",
"static",
"int",
"[",
"]",
"find",
"col",
"indices",
"(",
"string",
"[",
"]",
"table",
"cols",
",",
"string",
"[",
"]",
"target",
"cols",
")",
"{",
"if",
"(",
"target",
"cols",
"=",
"=",
"null",
")",
"{",
"int",
"[",
"]",
"indices",
"=",
"new",
"int",
"[",
"table",
"cols",
"length",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"table",
"cols",
"length",
";",
"i",
"+",
"+",
")",
"{",
"indices",
"[",
"i",
"]",
"=",
"i",
";",
"}",
"return",
"indices",
";",
"}",
"int",
"[",
"]",
"indices",
"=",
"new",
"int",
"[",
"target",
"cols",
"length",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"indices",
"length",
";",
"i",
"+",
"+",
")",
"{",
"indices",
"[",
"i",
"]",
"=",
"find",
"col",
"index",
"(",
"table",
"cols",
",",
"target",
"cols",
"[",
"i",
"]",
")",
";",
"}",
"return",
"indices",
";",
"}"
] |
[
"replace",
"the",
"given",
"advisor",
"<",
"b",
">",
"note",
":",
"<",
"b",
">",
"if",
"the",
"advisor",
"is",
"an",
"{",
"@",
"link",
"org",
"springframework",
"aop",
"introduction",
"advisor",
"}",
"and",
"the",
"replacement",
"is",
"not",
"or",
"implements",
"different",
"interfaces",
",",
"the",
"proxy",
"will",
"need",
"to",
"be",
"re",
"-",
"obtained",
"or",
"the",
"old",
"interfaces",
"won",
"'",
"t",
"be",
"supported",
"and",
"the",
"new",
"interface",
"won",
"'",
"t",
"be",
"implemented"
] | [
"boolean",
"replace",
"advisor",
"(",
"advisor",
"a",
",",
"advisor",
"b",
")",
"throws",
"aop",
"config",
"exception",
";"
] |
[
"determine",
"if",
"this",
"member",
"is",
"a",
"structure",
"container"
] | [
"boolean",
"is",
"structure",
"container",
"(",
")",
"{",
"return",
"structure",
"member",
"offset",
"map",
"!",
"=",
"null",
";",
"}"
] |
[
"add",
"a",
"maximum",
"statistic",
"to",
"dynamically",
"return",
"the",
"latest",
"value",
"of",
"the",
"source"
] | [
"public",
"dynamic",
"i",
"o",
"statistics",
"builder",
"with",
"atomic",
"long",
"maximum",
"(",
"string",
"key",
",",
"atomic",
"long",
"source",
")",
"{",
"with",
"long",
"function",
"maximum",
"(",
"key",
",",
"s",
"-",
">",
"source",
"get",
"(",
")",
")",
";",
"return",
"this",
";",
"}"
] |
[
"invoked",
"every",
"time",
"the",
"{",
"@",
"link",
"section",
"}",
"fails",
"loading",
"new",
"elements"
] | [
"void",
"on",
"load",
"failed",
"(",
"boolean",
"empty",
")",
";"
] |
[
"test",
"serialization",
"of",
"object",
"with",
"outer",
"number",
"type"
] | [
"public",
"void",
"fake",
"outer",
"composite",
"serialize",
"test",
"(",
")",
"{",
"outer",
"composite",
"outer",
"composite",
"=",
"null",
";",
"outer",
"composite",
"response",
"=",
"api",
"fake",
"outer",
"composite",
"serialize",
"(",
"outer",
"composite",
")",
"block",
"(",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
] |
[
"the",
"creation",
"timestamp",
"of",
"the",
"resource",
"<",
"code",
">",
"google",
"protobuf",
"timestamp",
"create",
"time",
"=",
"2",
";",
"<",
"code",
">"
] | [
"public",
"boolean",
"has",
"create",
"time",
"(",
")",
"{",
"return",
"create",
"time",
"builder",
"!",
"=",
"null",
"|",
"|",
"create",
"time",
"!",
"=",
"null",
";",
"}"
] |
[
"given",
"a",
"collection",
"of",
"strings",
",",
"work",
"out",
"which",
"(",
"if",
"any",
")",
"of",
"the",
"grok",
"patterns",
"we",
"'",
"re",
"allowed",
"to",
"use",
"matches",
"it",
"best",
"then",
"append",
"the",
"appropriate",
"grok",
"language",
"to",
"represent",
"that",
"finding",
"onto",
"the",
"supplied",
"string",
"builder"
] | [
"static",
"void",
"append",
"best",
"grok",
"match",
"for",
"strings",
"(",
"string",
"job",
"id",
",",
"map",
"<",
"string",
",",
"integer",
">",
"field",
"name",
"count",
"store",
",",
"string",
"builder",
"overall",
"grok",
"pattern",
"builder",
",",
"boolean",
"is",
"first",
",",
"boolean",
"is",
"last",
",",
"collection",
"<",
"string",
">",
"must",
"match",
"strings",
")",
"{",
"append",
"best",
"grok",
"match",
"for",
"strings",
"(",
"job",
"id",
",",
"field",
"name",
"count",
"store",
",",
"overall",
"grok",
"pattern",
"builder",
",",
"is",
"first",
",",
"is",
"last",
",",
"must",
"match",
"strings",
",",
"0",
")",
";",
"}"
] |
[
"gets",
"the",
"address",
"of",
"the",
"start",
"of",
"the",
"lsda"
] | [
"public",
"address",
"get",
"l",
"s",
"d",
"a",
"address",
"(",
"address",
"addr",
")",
"{",
"return",
"lsda",
"address",
";",
"}"
] |
[
"get",
"enum",
"string"
] | [
"public",
"enum",
"string",
"enum",
"get",
"enum",
"string",
"(",
")",
"{",
"return",
"enum",
"string",
";",
"}"
] |
[
"get",
"details",
"about",
"the",
"setup",
"of",
"the",
"connect",
"cluster"
] | [
"default",
"connect",
"cluster",
"details",
"cluster",
"details",
"(",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
")",
";",
"}"
] |
[
"indicates",
"that",
"the",
"salient",
"type",
"of",
"this",
"operation",
"is",
"as",
"given",
"this",
"differentiates",
"between",
",",
"for",
"example",
",",
"the",
"various",
"arithmetic",
"opcodes",
",",
"which",
",",
"by",
"the",
"time",
"they",
"hit",
"a",
"{",
"@",
"code",
"machine",
"}",
"are",
"collapsed",
"to",
"the",
"{",
"@",
"code",
"int",
"}",
"variant",
"(",
"see",
"{",
"@",
"link",
"bytecode",
"array",
"#",
"parse",
"instruction",
"}",
"for",
"details",
")"
] | [
"public",
"void",
"aux",
"type",
"(",
"type",
"type",
")",
";"
] |
[
"convenience",
"method",
"that",
"returns",
"a",
"{",
"@",
"link",
"file",
"type",
"#",
"classpath",
"}",
"file",
"handle"
] | [
"public",
"file",
"handle",
"classpath",
"(",
"string",
"path",
")",
";"
] |
[
"encodes",
"the",
"given",
"binary",
"content",
"as",
"an",
"aztec",
"symbol",
"(",
"without",
"eci",
"code",
")"
] | [
"public",
"static",
"aztec",
"code",
"encode",
"(",
"byte",
"[",
"]",
"data",
")",
"{",
"return",
"encode",
"(",
"data",
",",
"default",
"ec",
"percent",
",",
"default",
"aztec",
"layers",
",",
"null",
")",
";",
"}"
] |
[
"merges",
"a",
"new",
"mapping",
"into",
"the",
"existing",
"one"
] | [
"mapping",
"merge",
"(",
"mapping",
"merge",
"with",
",",
"merge",
"reason",
"reason",
")",
"{",
"root",
"object",
"mapper",
"merged",
"root",
"=",
"root",
"merge",
"(",
"merge",
"with",
"root",
",",
"reason",
")",
";",
"/",
"/",
"when",
"merging",
"metadata",
"fields",
"as",
"part",
"of",
"applying",
"an",
"index",
"template",
",",
"new",
"field",
"definitions",
"/",
"/",
"completely",
"overwrite",
"existing",
"ones",
"instead",
"of",
"being",
"merged",
"this",
"behavior",
"matches",
"how",
"we",
"/",
"/",
"merge",
"leaf",
"fields",
"in",
"the",
"'",
"properties",
"'",
"section",
"of",
"the",
"mapping",
"map",
"<",
"class",
"<",
"?",
"extends",
"metadata",
"field",
"mapper",
">",
",",
"metadata",
"field",
"mapper",
">",
"merged",
"metadata",
"mappers",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
"metadata",
"mappers",
"map",
")",
";",
"for",
"(",
"metadata",
"field",
"mapper",
"meta",
"merge",
"with",
":",
"merge",
"with",
"metadata",
"mappers",
")",
"{",
"metadata",
"field",
"mapper",
"merge",
"into",
"=",
"merged",
"metadata",
"mappers",
"get",
"(",
"meta",
"merge",
"with",
"get",
"class",
"(",
")",
")",
";",
"metadata",
"field",
"mapper",
"merged",
";",
"if",
"(",
"merge",
"into",
"=",
"=",
"null",
"|",
"|",
"reason",
"=",
"=",
"merge",
"reason",
"index",
"template",
")",
"{",
"merged",
"=",
"meta",
"merge",
"with",
";",
"}",
"else",
"{",
"merged",
"=",
"(",
"metadata",
"field",
"mapper",
")",
"merge",
"into",
"merge",
"(",
"meta",
"merge",
"with",
")",
";",
"}",
"merged",
"metadata",
"mappers",
"put",
"(",
"merged",
"get",
"class",
"(",
")",
",",
"merged",
")",
";",
"}",
"/",
"/",
"if",
"we",
"are",
"merging",
"the",
"meta",
"object",
"as",
"part",
"of",
"applying",
"an",
"index",
"template",
",",
"then",
"the",
"new",
"object",
"/",
"/",
"is",
"deep",
"-",
"merged",
"into",
"the",
"existing",
"one",
"to",
"allow",
"individual",
"keys",
"to",
"be",
"added",
"or",
"overwritten",
"for",
"/",
"/",
"standard",
"mapping",
"updates",
",",
"the",
"new",
"meta",
"object",
"completely",
"replaces",
"the",
"old",
"one",
"map",
"<",
"string",
",",
"object",
">",
"merged",
"meta",
";",
"if",
"(",
"merge",
"with",
"meta",
"=",
"=",
"null",
")",
"{",
"merged",
"meta",
"=",
"meta",
";",
"}",
"else",
"if",
"(",
"meta",
"=",
"=",
"null",
"|",
"|",
"reason",
"!",
"=",
"merge",
"reason",
"index",
"template",
")",
"{",
"merged",
"meta",
"=",
"merge",
"with",
"meta",
";",
"}",
"else",
"{",
"merged",
"meta",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
"merge",
"with",
"meta",
")",
";",
"x",
"content",
"helper",
"merge",
"defaults",
"(",
"merged",
"meta",
",",
"meta",
")",
";",
"}",
"return",
"new",
"mapping",
"(",
"merged",
"root",
",",
"merged",
"metadata",
"mappers",
"values",
"(",
")",
"to",
"array",
"(",
"new",
"metadata",
"field",
"mapper",
"[",
"0",
"]",
")",
",",
"merged",
"meta",
")",
";",
"}"
] |
[
"sync",
"two",
"replicas"
] | [
"private",
"void",
"test",
"sync",
"replicas",
"(",
"replica",
"recovery",
"info",
"replica",
"1",
",",
"replica",
"recovery",
"info",
"replica",
"2",
",",
"inter",
"datanode",
"protocol",
"dn",
"1",
",",
"inter",
"datanode",
"protocol",
"dn",
"2",
",",
"long",
"expect",
"len",
")",
"throws",
"i",
"o",
"exception",
"{",
"datanode",
"info",
"[",
"]",
"locs",
"=",
"new",
"datanode",
"info",
"[",
"]",
"{",
"mock",
"(",
"datanode",
"info",
"class",
")",
",",
"mock",
"(",
"datanode",
"info",
"class",
")",
"}",
";",
"recovering",
"block",
"r",
"block",
"=",
"new",
"recovering",
"block",
"(",
"block",
",",
"locs",
",",
"recovery",
"id",
")",
";",
"array",
"list",
"<",
"block",
"record",
">",
"sync",
"list",
"=",
"new",
"array",
"list",
"<",
"block",
"record",
">",
"(",
"2",
")",
";",
"block",
"record",
"record",
"1",
"=",
"new",
"block",
"record",
"(",
"d",
"f",
"s",
"test",
"util",
"get",
"datanode",
"info",
"(",
"\"",
"1",
"2",
"3",
"4",
"\"",
",",
"\"",
"bogus",
"\"",
",",
"1234",
")",
",",
"dn",
"1",
",",
"replica",
"1",
")",
";",
"block",
"record",
"record",
"2",
"=",
"new",
"block",
"record",
"(",
"d",
"f",
"s",
"test",
"util",
"get",
"datanode",
"info",
"(",
"\"",
"1",
"2",
"3",
"4",
"\"",
",",
"\"",
"bogus",
"\"",
",",
"1234",
")",
",",
"dn",
"2",
",",
"replica",
"2",
")",
";",
"sync",
"list",
"add",
"(",
"record",
"1",
")",
";",
"sync",
"list",
"add",
"(",
"record",
"2",
")",
";",
"when",
"(",
"dn",
"1",
"update",
"replica",
"under",
"recovery",
"(",
"any",
"(",
"extended",
"block",
"class",
")",
",",
"any",
"long",
"(",
")",
",",
"any",
"long",
"(",
")",
",",
"any",
"long",
"(",
")",
")",
")",
"then",
"return",
"(",
"\"",
"storage",
"1",
"\"",
")",
";",
"when",
"(",
"dn",
"2",
"update",
"replica",
"under",
"recovery",
"(",
"any",
"(",
"extended",
"block",
"class",
")",
",",
"any",
"long",
"(",
")",
",",
"any",
"long",
"(",
")",
",",
"any",
"long",
"(",
")",
")",
")",
"then",
"return",
"(",
"\"",
"storage",
"2",
"\"",
")",
";",
"block",
"recovery",
"worker",
"recovery",
"task",
"contiguous",
"recovery",
"task",
"contiguous",
"=",
"recovery",
"worker",
"new",
"recovery",
"task",
"contiguous",
"(",
"r",
"block",
")",
";",
"recovery",
"task",
"contiguous",
"sync",
"block",
"(",
"sync",
"list",
")",
";",
"}"
] |
[
"this",
"test",
"validates",
"that",
"an",
"index",
"which",
"is",
"out",
"of",
"bounds",
"throws",
"an",
"index",
"out",
"of",
"bounds",
"exception"
] | [
"public",
"void",
"test",
"out",
"of",
"tuple",
"bounds",
"dataset",
"3",
"(",
")",
"{",
"final",
"execution",
"environment",
"env",
"=",
"execution",
"environment",
"get",
"execution",
"environment",
"(",
")",
";",
"data",
"set",
"<",
"tuple",
"5",
"<",
"integer",
",",
"long",
",",
"string",
",",
"long",
",",
"integer",
">",
">",
"tuple",
"ds",
"=",
"env",
"from",
"collection",
"(",
"empty",
"tuple",
"data",
",",
"tuple",
"type",
"info",
")",
";",
"/",
"/",
"should",
"not",
"work",
",",
"key",
"out",
"of",
"tuple",
"bounds",
"tuple",
"ds",
"min",
"by",
"(",
"1",
",",
"2",
",",
"3",
",",
"4",
",",
"-",
"1",
")",
";",
"}"
] |
[
"map",
"the",
"route",
"for",
"http",
"trace",
"requests"
] | [
"public",
"static",
"void",
"trace",
"(",
"string",
"path",
",",
"template",
"view",
"route",
"route",
",",
"template",
"engine",
"engine",
")",
"{",
"get",
"instance",
"(",
")",
"trace",
"(",
"path",
",",
"route",
",",
"engine",
")",
";",
"}"
] |
[
"flip",
"the",
"opcode",
"so",
"to",
"avoid",
"the",
"name",
"collision",
"with",
"the",
"public",
"method"
] | [
"private",
"byte",
"[",
"]",
"frame",
"(",
"int",
"opcode",
",",
"byte",
"[",
"]",
"data",
",",
"int",
"error",
"code",
")",
"{",
"return",
"frame",
"(",
"opcode",
",",
"data",
",",
"error",
"code",
",",
"0",
",",
"data",
"length",
")",
";",
"}"
] |
[
"returns",
"the",
"maximum",
"number",
"of",
"operands",
"across",
"all",
"instructions",
"ie",
":",
"if",
"one",
"instruction",
"has",
"2",
"operands",
",",
"another",
"has",
"3",
",",
"and",
"another",
"has",
"5",
",",
"this",
"will",
"return",
"5"
] | [
"public",
"int",
"get",
"max",
"num",
"operands",
"(",
")",
"{",
"int",
"num",
"operands",
"=",
"0",
";",
"for",
"(",
"instruction",
"metadata",
"instruction",
":",
"instructions",
")",
"{",
"int",
"num",
"operands",
"temp",
"=",
"instruction",
"get",
"operands",
"(",
")",
"size",
"(",
")",
";",
"if",
"(",
"num",
"operands",
"temp",
">",
"num",
"operands",
")",
"{",
"num",
"operands",
"=",
"num",
"operands",
"temp",
";",
"}",
"}",
"return",
"num",
"operands",
";",
"}"
] |
[
"the",
"job",
"id",
"which",
"to",
"delete"
] | [
"public",
"void",
"set",
"job",
"id",
"(",
"string",
"job",
"id",
")",
"{",
"this",
"job",
"id",
"=",
"objects",
"require",
"non",
"null",
"(",
"job",
"id",
",",
"\"",
"[",
"job",
"id",
"]",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"}"
] |
[
"compute",
"the",
"path",
"where",
"the",
"output",
"of",
"a",
"given",
"job",
"attempt",
"will",
"be",
"placed"
] | [
"public",
"static",
"path",
"get",
"job",
"attempt",
"path",
"(",
"job",
"context",
"context",
",",
"path",
"out",
")",
"{",
"return",
"get",
"job",
"attempt",
"path",
"(",
"get",
"app",
"attempt",
"id",
"(",
"context",
")",
",",
"out",
")",
";",
"}"
] |
[
"like",
"{",
"@",
"link",
"#",
"fetch",
"block",
"byte",
"range",
"}",
"except",
"we",
"start",
"up",
"a",
"second",
",",
"parallel",
",",
"'",
"hedged",
"'",
"read",
"if",
"the",
"first",
"read",
"is",
"taking",
"longer",
"than",
"configured",
"amount",
"of",
"time",
"we",
"then",
"wait",
"on",
"which",
"ever",
"read",
"returns",
"first"
] | [
"private",
"void",
"hedged",
"fetch",
"block",
"byte",
"range",
"(",
"located",
"block",
"block",
",",
"long",
"start",
",",
"long",
"end",
",",
"byte",
"buffer",
"buf",
",",
"corrupted",
"blocks",
"corrupted",
"blocks",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"dfs",
"client",
"conf",
"conf",
"=",
"dfs",
"client",
"get",
"conf",
"(",
")",
";",
"array",
"list",
"<",
"future",
"<",
"byte",
"buffer",
">",
">",
"futures",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"completion",
"service",
"<",
"byte",
"buffer",
">",
"hedged",
"service",
"=",
"new",
"executor",
"completion",
"service",
"<",
">",
"(",
"dfs",
"client",
"get",
"hedged",
"reads",
"thread",
"pool",
"(",
")",
")",
";",
"array",
"list",
"<",
"datanode",
"info",
">",
"ignored",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"byte",
"buffer",
"bb",
";",
"int",
"len",
"=",
"(",
"int",
")",
"(",
"end",
"-",
"start",
"+",
"1",
")",
";",
"int",
"hedged",
"read",
"id",
"=",
"0",
";",
"while",
"(",
"true",
")",
"{",
"/",
"/",
"see",
"hdfs",
"-",
"6591",
",",
"this",
"metric",
"is",
"used",
"to",
"verify",
"/",
"catch",
"unnecessary",
"loops",
"hedged",
"read",
"ops",
"loop",
"num",
"for",
"testing",
"+",
"+",
";",
"d",
"n",
"addr",
"pair",
"chosen",
"node",
"=",
"null",
";",
"/",
"/",
"there",
"is",
"no",
"request",
"already",
"executing",
"if",
"(",
"futures",
"is",
"empty",
"(",
")",
")",
"{",
"/",
"/",
"choose",
"data",
"node",
"is",
"a",
"commitment",
"if",
"no",
"node",
",",
"we",
"go",
"to",
"/",
"/",
"the",
"nn",
"to",
"reget",
"block",
"locations",
"only",
"go",
"here",
"on",
"first",
"read",
"chosen",
"node",
"=",
"choose",
"data",
"node",
"(",
"block",
",",
"ignored",
")",
";",
"/",
"/",
"latest",
"block",
",",
"if",
"refreshed",
"internally",
"block",
"=",
"chosen",
"node",
"block",
";",
"bb",
"=",
"byte",
"buffer",
"allocate",
"(",
"len",
")",
";",
"callable",
"<",
"byte",
"buffer",
">",
"get",
"from",
"data",
"node",
"callable",
"=",
"get",
"from",
"one",
"data",
"node",
"(",
"chosen",
"node",
",",
"block",
",",
"start",
",",
"end",
",",
"bb",
",",
"corrupted",
"blocks",
",",
"hedged",
"read",
"id",
"+",
"+",
")",
";",
"future",
"<",
"byte",
"buffer",
">",
"first",
"request",
"=",
"hedged",
"service",
"submit",
"(",
"get",
"from",
"data",
"node",
"callable",
")",
";",
"futures",
"add",
"(",
"first",
"request",
")",
";",
"future",
"<",
"byte",
"buffer",
">",
"future",
"=",
"null",
";",
"try",
"{",
"future",
"=",
"hedged",
"service",
"poll",
"(",
"conf",
"get",
"hedged",
"read",
"threshold",
"millis",
"(",
")",
",",
"time",
"unit",
"milliseconds",
")",
";",
"if",
"(",
"future",
"!",
"=",
"null",
")",
"{",
"byte",
"buffer",
"result",
"=",
"future",
"get",
"(",
")",
";",
"result",
"flip",
"(",
")",
";",
"buf",
"put",
"(",
"result",
")",
";",
"return",
";",
"}",
"d",
"f",
"s",
"client",
"log",
"debug",
"(",
"\"",
"waited",
"{",
"}",
"ms",
"to",
"read",
"from",
"{",
"}",
";",
"spawning",
"hedged",
"\"",
"+",
"\"",
"read",
"\"",
",",
"conf",
"get",
"hedged",
"read",
"threshold",
"millis",
"(",
")",
",",
"chosen",
"node",
"info",
")",
";",
"dfs",
"client",
"get",
"hedged",
"read",
"metrics",
"(",
")",
"inc",
"hedged",
"read",
"ops",
"(",
")",
";",
"/",
"/",
"continue",
";",
"no",
"need",
"to",
"refresh",
"block",
"locations",
"}",
"catch",
"(",
"execution",
"exception",
"e",
")",
"{",
"futures",
"remove",
"(",
"future",
")",
";",
"}",
"catch",
"(",
"interrupted",
"exception",
"e",
")",
"{",
"throw",
"new",
"interrupted",
"i",
"o",
"exception",
"(",
"\"",
"interrupted",
"while",
"waiting",
"for",
"reading",
"task",
"\"",
")",
";",
"}",
"/",
"/",
"ignore",
"this",
"node",
"on",
"next",
"go",
"around",
"/",
"/",
"if",
"poll",
"timeout",
"and",
"the",
"request",
"still",
"ongoing",
",",
"don",
"'",
"t",
"consider",
"it",
"/",
"/",
"again",
"if",
"read",
"data",
"failed",
",",
"don",
"'",
"t",
"consider",
"it",
"either",
"ignored",
"add",
"(",
"chosen",
"node",
"info",
")",
";",
"}",
"else",
"{",
"/",
"/",
"we",
"are",
"starting",
"up",
"a",
"'",
"hedged",
"'",
"read",
"we",
"have",
"a",
"read",
"already",
"/",
"/",
"ongoing",
"call",
"get",
"best",
"node",
"d",
"n",
"addr",
"pair",
"instead",
"of",
"choose",
"data",
"node",
"/",
"/",
"if",
"no",
"nodes",
"to",
"do",
"hedged",
"reads",
"against",
",",
"pass",
"boolean",
"refetch",
"=",
"false",
";",
"try",
"{",
"chosen",
"node",
"=",
"choose",
"data",
"node",
"(",
"block",
",",
"ignored",
",",
"false",
")",
";",
"if",
"(",
"chosen",
"node",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"latest",
"block",
",",
"if",
"refreshed",
"internally",
"block",
"=",
"chosen",
"node",
"block",
";",
"bb",
"=",
"byte",
"buffer",
"allocate",
"(",
"len",
")",
";",
"callable",
"<",
"byte",
"buffer",
">",
"get",
"from",
"data",
"node",
"callable",
"=",
"get",
"from",
"one",
"data",
"node",
"(",
"chosen",
"node",
",",
"block",
",",
"start",
",",
"end",
",",
"bb",
",",
"corrupted",
"blocks",
",",
"hedged",
"read",
"id",
"+",
"+",
")",
";",
"future",
"<",
"byte",
"buffer",
">",
"one",
"more",
"request",
"=",
"hedged",
"service",
"submit",
"(",
"get",
"from",
"data",
"node",
"callable",
")",
";",
"futures",
"add",
"(",
"one",
"more",
"request",
")",
";",
"}",
"else",
"{",
"refetch",
"=",
"true",
";",
"}",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ioe",
")",
"{",
"d",
"f",
"s",
"client",
"log",
"debug",
"(",
"\"",
"failed",
"getting",
"node",
"for",
"hedged",
"read",
":",
"{",
"}",
"\"",
",",
"ioe",
"get",
"message",
"(",
")",
")",
";",
"}",
"/",
"/",
"if",
"not",
"succeeded",
"submit",
"callables",
"for",
"each",
"datanode",
"in",
"a",
"loop",
",",
"wait",
"/",
"/",
"for",
"a",
"fixed",
"interval",
"and",
"get",
"the",
"result",
"from",
"the",
"fastest",
"one",
"try",
"{",
"byte",
"buffer",
"result",
"=",
"get",
"first",
"to",
"complete",
"(",
"hedged",
"service",
",",
"futures",
")",
";",
"/",
"/",
"cancel",
"the",
"rest",
"cancel",
"all",
"(",
"futures",
")",
";",
"dfs",
"client",
"get",
"hedged",
"read",
"metrics",
"(",
")",
"inc",
"hedged",
"read",
"wins",
"(",
")",
";",
"result",
"flip",
"(",
")",
";",
"buf",
"put",
"(",
"result",
")",
";",
"return",
";",
"}",
"catch",
"(",
"interrupted",
"exception",
"ie",
")",
"{",
"/",
"/",
"ignore",
"and",
"retry",
"}",
"if",
"(",
"refetch",
")",
"{",
"refetch",
"locations",
"(",
"block",
",",
"ignored",
")",
";",
"}",
"/",
"/",
"we",
"got",
"here",
"if",
"exception",
"ignore",
"this",
"node",
"on",
"next",
"go",
"around",
"iff",
"/",
"/",
"we",
"found",
"a",
"chosen",
"node",
"to",
"hedge",
"read",
"against",
"if",
"(",
"chosen",
"node",
"!",
"=",
"null",
"&",
"&",
"chosen",
"node",
"info",
"!",
"=",
"null",
")",
"{",
"ignored",
"add",
"(",
"chosen",
"node",
"info",
")",
";",
"}",
"}",
"}",
"}"
] |
[
"start",
"the",
"activity"
] | [
"public",
"static",
"boolean",
"start",
"activity",
"(",
"@",
"non",
"null",
"final",
"intent",
"intent",
",",
"@",
"nullable",
"final",
"bundle",
"options",
")",
"{",
"return",
"start",
"activity",
"(",
"intent",
",",
"get",
"top",
"activity",
"or",
"app",
"(",
")",
",",
"options",
")",
";",
"}"
] |
[
"create",
"and",
"add",
"new",
"subfolder",
"data",
"object",
"to",
"cache",
"data",
"will",
"not",
"be",
"created",
"if",
"folder",
"does",
"not",
"exist",
"or",
"an",
"i",
"o",
"exception",
"occurs"
] | [
"private",
"ghidra",
"folder",
"data",
"add",
"folder",
"data",
"(",
"string",
"folder",
"name",
")",
"{",
"ghidra",
"folder",
"data",
"folder",
"data",
"=",
"folder",
"data",
"cache",
"get",
"(",
"folder",
"name",
")",
";",
"if",
"(",
"folder",
"data",
"=",
"=",
"null",
")",
"{",
"try",
"{",
"folder",
"data",
"=",
"new",
"ghidra",
"folder",
"data",
"(",
"this",
",",
"folder",
"name",
")",
";",
"folder",
"data",
"cache",
"put",
"(",
"folder",
"name",
",",
"folder",
"data",
")",
";",
"}",
"catch",
"(",
"file",
"not",
"found",
"exception",
"e",
")",
"{",
"/",
"/",
"ignore",
"}",
"}",
"return",
"folder",
"data",
";",
"}"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"returns",
"the",
"address",
"of",
"the",
"module",
"handle"
] | [
"public",
"long",
"get",
"address",
"of",
"module",
"handle",
"(",
")",
"{",
"return",
"phmod",
";",
"}"
] |
[
"called",
"when",
"an",
"m",
"bean",
"is",
"unregistered",
"under",
"the",
"given",
"{",
"@",
"link",
"object",
"name",
"}",
"allows",
"subclasses",
"to",
"perform",
"additional",
"processing",
"when",
"an",
"m",
"bean",
"is",
"unregistered",
"the",
"default",
"implementation",
"is",
"empty",
"can",
"be",
"overridden",
"in",
"subclasses"
] | [
"protected",
"void",
"on",
"unregister",
"(",
"object",
"name",
"object",
"name",
")",
"{",
"}"
] |
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
] | [
"private",
"string",
"to",
"indented",
"string",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"http",
":",
"tools",
"ietf",
"orghtmldraft",
"-",
"ietf",
"-",
"httpbis",
"-",
"header",
"-",
"compression",
"-",
"12",
"#",
"appendix",
"-",
"c",
"4"
] | [
"@",
"test",
"public",
"void",
"read",
"request",
"examples",
"with",
"huffman",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"first",
"request",
"with",
"huffman",
"(",
")",
";",
"hpack",
"reader",
"read",
"headers",
"(",
")",
";",
"check",
"read",
"first",
"request",
"with",
"huffman",
"(",
")",
";",
"second",
"request",
"with",
"huffman",
"(",
")",
";",
"hpack",
"reader",
"read",
"headers",
"(",
")",
";",
"check",
"read",
"second",
"request",
"with",
"huffman",
"(",
")",
";",
"third",
"request",
"with",
"huffman",
"(",
")",
";",
"hpack",
"reader",
"read",
"headers",
"(",
")",
";",
"check",
"read",
"third",
"request",
"with",
"huffman",
"(",
")",
";",
"}"
] |
[
"print",
"a",
"list",
"of",
"{",
"@",
"link",
"snapshot",
"status",
"}",
"out",
"to",
"a",
"given",
"stream"
] | [
"public",
"static",
"void",
"print",
"(",
"snapshot",
"status",
"[",
"]",
"stats",
",",
"print",
"stream",
"out",
")",
"{",
"if",
"(",
"stats",
"=",
"=",
"null",
"|",
"|",
"stats",
"length",
"=",
"=",
"0",
")",
"{",
"out",
"println",
"(",
")",
";",
"return",
";",
"}",
"int",
"max",
"repl",
"=",
"0",
",",
"max",
"len",
"=",
"0",
",",
"max",
"owner",
"=",
"0",
",",
"max",
"group",
"=",
"0",
";",
"int",
"max",
"snapshot",
"i",
"d",
"=",
"0",
";",
"for",
"(",
"snapshot",
"status",
"status",
":",
"stats",
")",
"{",
"max",
"repl",
"=",
"max",
"length",
"(",
"max",
"repl",
",",
"status",
"dir",
"status",
"get",
"replication",
"(",
")",
")",
";",
"max",
"len",
"=",
"max",
"length",
"(",
"max",
"len",
",",
"status",
"dir",
"status",
"get",
"len",
"(",
")",
")",
";",
"max",
"owner",
"=",
"max",
"length",
"(",
"max",
"owner",
",",
"status",
"dir",
"status",
"get",
"owner",
"(",
")",
")",
";",
"max",
"group",
"=",
"max",
"length",
"(",
"max",
"group",
",",
"status",
"dir",
"status",
"get",
"group",
"(",
")",
")",
";",
"max",
"snapshot",
"i",
"d",
"=",
"max",
"length",
"(",
"max",
"snapshot",
"i",
"d",
",",
"status",
"snapshot",
"i",
"d",
")",
";",
"}",
"string",
"line",
"format",
"=",
"\"",
"%",
"s",
"%",
"s",
"\"",
"/",
"/",
"permission",
"string",
"+",
"\"",
"%",
"\"",
"+",
"max",
"repl",
"+",
"\"",
"s",
"\"",
"+",
"(",
"max",
"owner",
">",
"0",
"?",
"\"",
"%",
"-",
"\"",
"+",
"max",
"owner",
"+",
"\"",
"s",
"\"",
":",
"\"",
"%",
"s",
"\"",
")",
"+",
"(",
"max",
"group",
">",
"0",
"?",
"\"",
"%",
"-",
"\"",
"+",
"max",
"group",
"+",
"\"",
"s",
"\"",
":",
"\"",
"%",
"s",
"\"",
")",
"+",
"\"",
"%",
"\"",
"+",
"max",
"len",
"+",
"\"",
"s",
"\"",
"+",
"\"",
"%",
"s",
"\"",
"/",
"/",
"mod",
"time",
"+",
"\"",
"%",
"\"",
"+",
"max",
"snapshot",
"i",
"d",
"+",
"\"",
"s",
"\"",
"+",
"\"",
"%",
"s",
"\"",
"/",
"/",
"deletion",
"status",
"+",
"\"",
"%",
"s",
"\"",
";",
"/",
"/",
"path",
"simple",
"date",
"format",
"date",
"format",
"=",
"new",
"simple",
"date",
"format",
"(",
"\"",
"yyyy",
"-",
"mm",
"-",
"dd",
"hh",
":",
"mm",
"\"",
")",
";",
"for",
"(",
"snapshot",
"status",
"status",
":",
"stats",
")",
"{",
"string",
"line",
"=",
"string",
"format",
"(",
"line",
"format",
",",
"\"",
"d",
"\"",
",",
"status",
"dir",
"status",
"get",
"permission",
"(",
")",
",",
"status",
"dir",
"status",
"get",
"replication",
"(",
")",
",",
"status",
"dir",
"status",
"get",
"owner",
"(",
")",
",",
"status",
"dir",
"status",
"get",
"group",
"(",
")",
",",
"string",
"value",
"of",
"(",
"status",
"dir",
"status",
"get",
"len",
"(",
")",
")",
",",
"date",
"format",
"format",
"(",
"new",
"date",
"(",
"status",
"dir",
"status",
"get",
"modification",
"time",
"(",
")",
")",
")",
",",
"status",
"snapshot",
"i",
"d",
",",
"status",
"is",
"deleted",
"?",
"\"",
"deleted",
"\"",
":",
"\"",
"active",
"\"",
",",
"get",
"snapshot",
"path",
"(",
"d",
"f",
"s",
"util",
"client",
"bytes",
"2",
"string",
"(",
"status",
"parent",
"full",
"path",
")",
",",
"status",
"dir",
"status",
"get",
"local",
"name",
"(",
")",
")",
")",
";",
"out",
"println",
"(",
"line",
")",
";",
"}",
"}"
] |
[
"same",
"as",
"{",
"@",
"link",
"#",
"create",
"(",
"path",
",",
"fs",
"permission",
",",
"boolean",
",",
"int",
",",
"short",
",",
"long",
",",
"progressable",
")",
"}",
"with",
"the",
"addition",
"of",
"favored",
"nodes",
"that",
"is",
"a",
"hint",
"to",
"where",
"the",
"namenode",
"should",
"place",
"the",
"file",
"blocks",
"the",
"favored",
"nodes",
"hint",
"is",
"not",
"persisted",
"in",
"hdfs",
"hence",
"it",
"may",
"be",
"honored",
"at",
"the",
"creation",
"time",
"only",
"and",
"with",
"favored",
"nodes",
",",
"blocks",
"will",
"be",
"pinned",
"on",
"the",
"datanodes",
"to",
"prevent",
"balancing",
"move",
"the",
"block",
"hdfs",
"could",
"move",
"the",
"blocks",
"during",
"replication",
",",
"to",
"move",
"the",
"blocks",
"from",
"favored",
"nodes",
"a",
"value",
"of",
"null",
"means",
"no",
"favored",
"nodes",
"for",
"this",
"create"
] | [
"public",
"hdfs",
"data",
"output",
"stream",
"create",
"(",
"final",
"path",
"f",
",",
"final",
"fs",
"permission",
"permission",
",",
"final",
"boolean",
"overwrite",
",",
"final",
"int",
"buffer",
"size",
",",
"final",
"short",
"replication",
",",
"final",
"long",
"block",
"size",
",",
"final",
"progressable",
"progress",
",",
"final",
"inet",
"socket",
"address",
"[",
"]",
"favored",
"nodes",
")",
"throws",
"i",
"o",
"exception",
"{",
"statistics",
"increment",
"write",
"ops",
"(",
"1",
")",
";",
"storage",
"statistics",
"increment",
"op",
"counter",
"(",
"op",
"type",
"create",
")",
";",
"path",
"abs",
"f",
"=",
"fix",
"relative",
"part",
"(",
"f",
")",
";",
"return",
"new",
"file",
"system",
"link",
"resolver",
"<",
"hdfs",
"data",
"output",
"stream",
">",
"(",
")",
"{",
"@",
"override",
"public",
"hdfs",
"data",
"output",
"stream",
"do",
"call",
"(",
"final",
"path",
"p",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"d",
"f",
"s",
"output",
"stream",
"out",
"=",
"dfs",
"create",
"(",
"get",
"path",
"name",
"(",
"f",
")",
",",
"permission",
",",
"overwrite",
"?",
"enum",
"set",
"of",
"(",
"create",
"flag",
"create",
",",
"create",
"flag",
"overwrite",
")",
":",
"enum",
"set",
"of",
"(",
"create",
"flag",
"create",
")",
",",
"true",
",",
"replication",
",",
"block",
"size",
",",
"progress",
",",
"buffer",
"size",
",",
"null",
",",
"favored",
"nodes",
")",
";",
"return",
"safely",
"create",
"wrapped",
"output",
"stream",
"(",
"out",
")",
";",
"}",
"@",
"override",
"public",
"hdfs",
"data",
"output",
"stream",
"next",
"(",
"final",
"file",
"system",
"fs",
",",
"final",
"path",
"p",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"fs",
"instanceof",
"distributed",
"file",
"system",
")",
"{",
"distributed",
"file",
"system",
"my",
"dfs",
"=",
"(",
"distributed",
"file",
"system",
")",
"fs",
";",
"return",
"my",
"dfs",
"create",
"(",
"p",
",",
"permission",
",",
"overwrite",
",",
"buffer",
"size",
",",
"replication",
",",
"block",
"size",
",",
"progress",
",",
"favored",
"nodes",
")",
";",
"}",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
"\"",
"cannot",
"create",
"with",
"\"",
"+",
"\"",
"favored",
"nodes",
"through",
"a",
"symlink",
"to",
"a",
"non",
"-",
"distributed",
"file",
"system",
":",
"\"",
"+",
"f",
"+",
"\"",
"-",
">",
"\"",
"+",
"p",
")",
";",
"}",
"}",
"resolve",
"(",
"this",
",",
"abs",
"f",
")",
";",
"}"
] |
[
"parses",
"the",
"given",
"stream",
"of",
"{",
"@",
"link",
"data",
"buffer",
"}",
"objects",
"into",
"a",
"stream",
"of",
"{",
"@",
"link",
"token",
"}",
"objects"
] | [
"public",
"static",
"flux",
"<",
"token",
">",
"parse",
"(",
"flux",
"<",
"data",
"buffer",
">",
"buffers",
",",
"byte",
"[",
"]",
"boundary",
",",
"int",
"max",
"headers",
"size",
")",
"{",
"return",
"flux",
"create",
"(",
"sink",
"-",
">",
"{",
"multipart",
"parser",
"parser",
"=",
"new",
"multipart",
"parser",
"(",
"sink",
",",
"boundary",
",",
"max",
"headers",
"size",
")",
";",
"sink",
"on",
"cancel",
"(",
"parser",
":",
":",
"on",
"sink",
"cancel",
")",
";",
"sink",
"on",
"request",
"(",
"n",
"-",
">",
"parser",
"request",
"buffer",
"(",
")",
")",
";",
"buffers",
"subscribe",
"(",
"parser",
")",
";",
"}",
")",
";",
"}"
] |
[
"test",
"to",
"verify",
"i",
"p",
"failover",
"proxy",
"provider",
"is",
"not",
"requiring",
"logical",
"uri"
] | [
"public",
"void",
"test",
"i",
"p",
"failover",
"proxy",
"provider",
"logical",
"uri",
"(",
")",
"throws",
"exception",
"{",
"/",
"/",
"setup",
"the",
"config",
"with",
"the",
"ip",
"failover",
"proxy",
"provider",
"class",
"configuration",
"config",
"=",
"new",
"hdfs",
"configuration",
"(",
"conf",
")",
";",
"uri",
"nn",
"uri",
"=",
"cluster",
"get",
"u",
"r",
"i",
"(",
"0",
")",
";",
"config",
"set",
"(",
"hdfs",
"client",
"config",
"keys",
"failover",
"proxy",
"provider",
"key",
"prefix",
"+",
"\"",
"\"",
"+",
"nn",
"uri",
"get",
"host",
"(",
")",
",",
"i",
"p",
"failover",
"proxy",
"provider",
"class",
"get",
"name",
"(",
")",
")",
";",
"assert",
"false",
"(",
"\"",
"i",
"p",
"failover",
"proxy",
"provider",
"should",
"not",
"use",
"logical",
"uri",
"\"",
",",
"h",
"a",
"util",
"use",
"logical",
"uri",
"(",
"config",
",",
"nn",
"uri",
")",
")",
";",
"}"
] |
[
"returns",
"a",
"read",
"-",
"only",
"slice",
"of",
"this",
"buffer",
"reader",
"and",
"writer",
"indices",
"as",
"well",
"as",
"markers",
"are",
"not",
"shared",
"reference",
"counters",
"are",
"shared",
"but",
"the",
"slice",
"is",
"not",
"{",
"@",
"link",
"#",
"retain",
"buffer",
"(",
")",
"retained",
"}",
"automatically"
] | [
"buffer",
"read",
"only",
"slice",
"(",
"int",
"index",
",",
"int",
"length",
")",
";"
] |
[
"return",
"the",
"underlying",
"{",
"@",
"code",
"org",
"apache",
"commons",
"fileupload",
"disk",
"disk",
"file",
"item",
"factory",
"}",
"instance",
"there",
"is",
"hardly",
"any",
"need",
"to",
"access",
"this"
] | [
"public",
"disk",
"file",
"item",
"factory",
"get",
"file",
"item",
"factory",
"(",
")",
"{",
"return",
"this",
"file",
"item",
"factory",
";",
"}"
] |
[
"copy",
"a",
"ctx",
"(",
"i",
"'",
"m",
"deliberately",
"not",
"using",
"copy",
"constructor",
")",
"to",
"avoid",
"confusion",
"with",
"creating",
"node",
"with",
"parent",
"does",
"not",
"copy",
"children",
"(",
"except",
"error",
"leaves",
")",
"this",
"is",
"used",
"in",
"the",
"generated",
"parser",
"code",
"to",
"flip",
"a",
"generic",
"x",
"context",
"node",
"for",
"rule",
"x",
"to",
"a",
"y",
"context",
"for",
"alt",
"label",
"y",
"in",
"that",
"sense",
",",
"it",
"is",
"not",
"really",
"a",
"generic",
"copy",
"function",
"if",
"we",
"do",
"an",
"error",
"sync",
"(",
")",
"at",
"start",
"of",
"a",
"rule",
",",
"we",
"might",
"add",
"error",
"nodes",
"to",
"the",
"generic",
"x",
"context",
"so",
"this",
"function",
"must",
"copy",
"those",
"nodes",
"to",
"the",
"y",
"context",
"as",
"well",
"else",
"they",
"are",
"lost",
"!"
] | [
"public",
"void",
"copy",
"from",
"(",
"parser",
"rule",
"context",
"ctx",
")",
"{",
"this",
"parent",
"=",
"ctx",
"parent",
";",
"this",
"invoking",
"state",
"=",
"ctx",
"invoking",
"state",
";",
"this",
"start",
"=",
"ctx",
"start",
";",
"this",
"stop",
"=",
"ctx",
"stop",
";",
"/",
"/",
"copy",
"any",
"error",
"nodes",
"to",
"alt",
"label",
"node",
"if",
"(",
"ctx",
"children",
"!",
"=",
"null",
")",
"{",
"this",
"children",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"/",
"/",
"reset",
"parent",
"pointer",
"for",
"any",
"error",
"nodes",
"for",
"(",
"parse",
"tree",
"child",
":",
"ctx",
"children",
")",
"{",
"if",
"(",
"child",
"instanceof",
"error",
"node",
")",
"{",
"add",
"child",
"(",
"(",
"error",
"node",
")",
"child",
")",
";",
"}",
"}",
"}",
"}"
] |
[
"gets",
"the",
"address",
"immediately",
"after",
"this",
"instance",
"this",
"is",
"only",
"calculable",
"if",
"this",
"instance",
"'",
"s",
"address",
"is",
"known",
",",
"and",
"it",
"is",
"equal",
"to",
"the",
"address",
"plus",
"the",
"length",
"of",
"the",
"instruction",
"format",
"of",
"this",
"instance",
"'",
"s",
"opcode"
] | [
"public",
"final",
"int",
"get",
"next",
"address",
"(",
")",
"{",
"return",
"get",
"address",
"(",
")",
"+",
"code",
"size",
"(",
")",
";",
"}"
] |
[
"returns",
"the",
"merged",
"transient",
"and",
"persistent",
"settings"
] | [
"public",
"settings",
"settings",
"(",
")",
"{",
"return",
"this",
"settings",
";",
"}"
] |
[
"performs",
"a",
"cas",
"operation",
"on",
"the",
"{",
"@",
"link",
"#",
"value",
"}",
"field"
] | [
"boolean",
"cas",
"value",
"(",
"abstract",
"future",
"<",
"?",
">",
"future",
",",
"object",
"expect",
",",
"object",
"update",
")",
"{",
"return",
"unsafe",
"compare",
"and",
"swap",
"object",
"(",
"future",
",",
"value",
"offset",
",",
"expect",
",",
"update",
")",
";",
"}"
] |
[
"get",
"the",
"<",
"b",
">",
"signed",
"<",
"b",
">",
"value",
"from",
"the",
"given",
"byte",
"array",
"using",
"the",
"specified",
"integer",
"size",
",",
"returned",
"as",
"a",
"long",
"values",
"with",
"a",
"size",
"less",
"than",
"sizeof",
"(",
"long",
")",
"will",
"have",
"their",
"sign",
"bit",
"extended"
] | [
"default",
"long",
"get",
"signed",
"value",
"(",
"byte",
"[",
"]",
"b",
",",
"int",
"size",
")",
"{",
"return",
"get",
"signed",
"value",
"(",
"b",
",",
"0",
",",
"size",
")",
";",
"}"
] |
[
"synchronously",
"calls",
"the",
"reload",
"search",
"analyzers",
"api"
] | [
"public",
"reload",
"analyzers",
"response",
"reload",
"analyzers",
"(",
"reload",
"analyzers",
"request",
"request",
",",
"request",
"options",
"options",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"rest",
"high",
"level",
"client",
"perform",
"request",
"and",
"parse",
"entity",
"(",
"request",
",",
"indices",
"request",
"converters",
":",
":",
"reload",
"analyzers",
",",
"options",
",",
"reload",
"analyzers",
"response",
":",
":",
"from",
"x",
"content",
",",
"empty",
"set",
"(",
")",
")",
";",
"}"
] |
[
"the",
"failure",
"message"
] | [
"public",
"string",
"to",
"string",
"(",
")",
"{",
"return",
"message",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"build",
"call",
"for",
"test",
"endpoint",
"parameters"
] | [
"public",
"okhttp",
"3",
"call",
"test",
"endpoint",
"parameters",
"call",
"(",
"big",
"decimal",
"number",
",",
"double",
"double",
",",
"string",
"pattern",
"without",
"delimiter",
",",
"byte",
"[",
"]",
"byte",
",",
"integer",
"integer",
",",
"integer",
"int",
"3",
"2",
",",
"long",
"int",
"6",
"4",
",",
"float",
"float",
",",
"string",
"string",
",",
"file",
"binary",
",",
"local",
"date",
"date",
",",
"offset",
"date",
"time",
"date",
"time",
",",
"string",
"password",
",",
"string",
"param",
"callback",
",",
"final",
"api",
"callback",
"callback",
")",
"throws",
"api",
"exception",
"{",
"object",
"local",
"var",
"post",
"body",
"=",
"null",
";",
"/",
"/",
"create",
"path",
"and",
"map",
"variables",
"string",
"local",
"var",
"path",
"=",
"\"",
"/",
"fake",
"\"",
";",
"list",
"<",
"pair",
">",
"local",
"var",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"list",
"<",
"pair",
">",
"local",
"var",
"collection",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"header",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"cookie",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"object",
">",
"local",
"var",
"form",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"if",
"(",
"integer",
"!",
"=",
"null",
")",
"{",
"local",
"var",
"form",
"params",
"put",
"(",
"\"",
"integer",
"\"",
",",
"integer",
")",
";",
"}",
"if",
"(",
"int",
"3",
"2",
"!",
"=",
"null",
")",
"{",
"local",
"var",
"form",
"params",
"put",
"(",
"\"",
"int",
"3",
"2",
"\"",
",",
"int",
"3",
"2",
")",
";",
"}",
"if",
"(",
"int",
"6",
"4",
"!",
"=",
"null",
")",
"{",
"local",
"var",
"form",
"params",
"put",
"(",
"\"",
"int",
"6",
"4",
"\"",
",",
"int",
"6",
"4",
")",
";",
"}",
"if",
"(",
"number",
"!",
"=",
"null",
")",
"{",
"local",
"var",
"form",
"params",
"put",
"(",
"\"",
"number",
"\"",
",",
"number",
")",
";",
"}",
"if",
"(",
"float",
"!",
"=",
"null",
")",
"{",
"local",
"var",
"form",
"params",
"put",
"(",
"\"",
"float",
"\"",
",",
"float",
")",
";",
"}",
"if",
"(",
"double",
"!",
"=",
"null",
")",
"{",
"local",
"var",
"form",
"params",
"put",
"(",
"\"",
"double",
"\"",
",",
"double",
")",
";",
"}",
"if",
"(",
"string",
"!",
"=",
"null",
")",
"{",
"local",
"var",
"form",
"params",
"put",
"(",
"\"",
"string",
"\"",
",",
"string",
")",
";",
"}",
"if",
"(",
"pattern",
"without",
"delimiter",
"!",
"=",
"null",
")",
"{",
"local",
"var",
"form",
"params",
"put",
"(",
"\"",
"pattern",
"without",
"delimiter",
"\"",
",",
"pattern",
"without",
"delimiter",
")",
";",
"}",
"if",
"(",
"byte",
"!",
"=",
"null",
")",
"{",
"local",
"var",
"form",
"params",
"put",
"(",
"\"",
"byte",
"\"",
",",
"byte",
")",
";",
"}",
"if",
"(",
"binary",
"!",
"=",
"null",
")",
"{",
"local",
"var",
"form",
"params",
"put",
"(",
"\"",
"binary",
"\"",
",",
"binary",
")",
";",
"}",
"if",
"(",
"date",
"!",
"=",
"null",
")",
"{",
"local",
"var",
"form",
"params",
"put",
"(",
"\"",
"date",
"\"",
",",
"date",
")",
";",
"}",
"if",
"(",
"date",
"time",
"!",
"=",
"null",
")",
"{",
"local",
"var",
"form",
"params",
"put",
"(",
"\"",
"date",
"time",
"\"",
",",
"date",
"time",
")",
";",
"}",
"if",
"(",
"password",
"!",
"=",
"null",
")",
"{",
"local",
"var",
"form",
"params",
"put",
"(",
"\"",
"password",
"\"",
",",
"password",
")",
";",
"}",
"if",
"(",
"param",
"callback",
"!",
"=",
"null",
")",
"{",
"local",
"var",
"form",
"params",
"put",
"(",
"\"",
"callback",
"\"",
",",
"param",
"callback",
")",
";",
"}",
"final",
"string",
"[",
"]",
"local",
"var",
"accepts",
"=",
"{",
"}",
";",
"final",
"string",
"local",
"var",
"accept",
"=",
"local",
"var",
"api",
"client",
"select",
"header",
"accept",
"(",
"local",
"var",
"accepts",
")",
";",
"if",
"(",
"local",
"var",
"accept",
"!",
"=",
"null",
")",
"{",
"local",
"var",
"header",
"params",
"put",
"(",
"\"",
"accept",
"\"",
",",
"local",
"var",
"accept",
")",
";",
"}",
"final",
"string",
"[",
"]",
"local",
"var",
"content",
"types",
"=",
"{",
"\"",
"application",
"/",
"x",
"-",
"www",
"-",
"form",
"-",
"urlencoded",
"\"",
"}",
";",
"final",
"string",
"local",
"var",
"content",
"type",
"=",
"local",
"var",
"api",
"client",
"select",
"header",
"content",
"type",
"(",
"local",
"var",
"content",
"types",
")",
";",
"local",
"var",
"header",
"params",
"put",
"(",
"\"",
"content",
"-",
"type",
"\"",
",",
"local",
"var",
"content",
"type",
")",
";",
"string",
"[",
"]",
"local",
"var",
"auth",
"names",
"=",
"new",
"string",
"[",
"]",
"{",
"\"",
"http",
"basic",
"test",
"\"",
"}",
";",
"return",
"local",
"var",
"api",
"client",
"build",
"call",
"(",
"local",
"var",
"path",
",",
"\"",
"post",
"\"",
",",
"local",
"var",
"query",
"params",
",",
"local",
"var",
"collection",
"query",
"params",
",",
"local",
"var",
"post",
"body",
",",
"local",
"var",
"header",
"params",
",",
"local",
"var",
"cookie",
"params",
",",
"local",
"var",
"form",
"params",
",",
"local",
"var",
"auth",
"names",
",",
"callback",
")",
";",
"}"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"set",
"the",
"active",
"project"
] | [
"public",
"void",
"set",
"active",
"project",
"(",
"project",
"project",
")",
"{",
"if",
"(",
"is",
"disposed",
")",
"{",
"return",
";",
"}",
"tool",
"options",
"options",
"=",
"get",
"options",
"(",
"tool",
"constants",
"tool",
"options",
")",
";",
"options",
"remove",
"options",
"change",
"listener",
"(",
"this",
")",
";",
"configure",
"tool",
"action",
"set",
"enabled",
"(",
"true",
")",
";",
"set",
"project",
"(",
"project",
")",
";",
"app",
"info",
"set",
"active",
"project",
"(",
"project",
")",
";",
"plugin",
"set",
"active",
"project",
"(",
"project",
")",
";",
"init",
"front",
"end",
"options",
"(",
")",
";",
"}"
] |
[
"set",
"the",
"linear",
"velocity",
"of",
"the",
"center",
"of",
"mass"
] | [
"public",
"void",
"set",
"linear",
"velocity",
"(",
"float",
"v",
"x",
",",
"float",
"v",
"y",
")",
"{",
"jni",
"set",
"linear",
"velocity",
"(",
"addr",
",",
"v",
"x",
",",
"v",
"y",
")",
";",
"}"
] |
[
"sets",
"the",
"name",
"of",
"the",
"data",
"type"
] | [
"public",
"void",
"set",
"name",
"(",
"string",
"name",
")",
"throws",
"invalid",
"name",
"exception",
",",
"duplicate",
"name",
"exception",
";"
] |
[
"waits",
"for",
"this",
"future",
"to",
"be",
"completed",
"within",
"the",
"specified",
"time",
"limit",
"without",
"interruption",
"this",
"method",
"catches",
"an",
"{",
"@",
"link",
"interrupted",
"exception",
"}",
"and",
"discards",
"it",
"silently"
] | [
"boolean",
"await",
"uninterruptibly",
"(",
"long",
"timeout",
"millis",
")",
";"
] |
[
"login",
"to",
"server"
] | [
"public",
"boolean",
"login",
"(",
"string",
"server",
")",
"{",
"if",
"(",
"string",
"utils",
"is",
"not",
"blank",
"(",
"username",
")",
")",
"{",
"map",
"<",
"string",
",",
"string",
">",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
"2",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"body",
"map",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
"2",
")",
";",
"params",
"put",
"(",
"\"",
"username",
"\"",
",",
"username",
")",
";",
"body",
"map",
"put",
"(",
"\"",
"password",
"\"",
",",
"password",
")",
";",
"string",
"url",
"=",
"\"",
"http",
":",
"/",
"/",
"\"",
"+",
"server",
"+",
"context",
"path",
"+",
"login",
"url",
";",
"if",
"(",
"server",
"contains",
"(",
"constants",
"http",
"prefix",
")",
")",
"{",
"url",
"=",
"server",
"+",
"context",
"path",
"+",
"login",
"url",
";",
"}",
"try",
"{",
"http",
"rest",
"result",
"<",
"string",
">",
"rest",
"result",
"=",
"nacos",
"rest",
"template",
"post",
"form",
"(",
"url",
",",
"header",
"empty",
",",
"query",
"new",
"instance",
"(",
")",
"init",
"params",
"(",
"params",
")",
",",
"body",
"map",
",",
"string",
"class",
")",
";",
"if",
"(",
"!",
"rest",
"result",
"ok",
"(",
")",
")",
"{",
"security",
"logger",
"error",
"(",
"\"",
"login",
"failed",
":",
"{",
"}",
"\"",
",",
"jackson",
"utils",
"to",
"json",
"(",
"rest",
"result",
")",
")",
";",
"return",
"false",
";",
"}",
"json",
"node",
"obj",
"=",
"jackson",
"utils",
"to",
"obj",
"(",
"rest",
"result",
"get",
"data",
"(",
")",
")",
";",
"if",
"(",
"obj",
"has",
"(",
"constants",
"access",
"token",
")",
")",
"{",
"access",
"token",
"=",
"obj",
"get",
"(",
"constants",
"access",
"token",
")",
"as",
"text",
"(",
")",
";",
"token",
"ttl",
"=",
"obj",
"get",
"(",
"constants",
"token",
"ttl",
")",
"as",
"int",
"(",
")",
";",
"token",
"refresh",
"window",
"=",
"token",
"ttl",
"/",
"10",
";",
"}",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"security",
"logger",
"error",
"(",
"\"",
"[",
"security",
"proxy",
"]",
"login",
"http",
"request",
"failed",
"\"",
"+",
"\"",
"url",
":",
"{",
"}",
",",
"params",
":",
"{",
"}",
",",
"body",
"map",
":",
"{",
"}",
",",
"error",
"msg",
":",
"{",
"}",
"\"",
",",
"url",
",",
"params",
",",
"body",
"map",
",",
"e",
"get",
"message",
"(",
")",
")",
";",
"return",
"false",
";",
"}",
"}",
"return",
"true",
";",
"}"
] |
[
"finds",
"the",
"firefox",
"version",
"of",
"the",
"given",
"webdriver",
"and",
"returns",
"it",
"as",
"an",
"integer",
"for",
"instance",
",",
"'",
"14",
"0",
"1",
"'",
"will",
"translate",
"to",
"14"
] | [
"public",
"static",
"int",
"get",
"firefox",
"version",
"(",
"web",
"driver",
"driver",
")",
"{",
"/",
"/",
"extract",
"browser",
"string",
"pattern",
"browser",
"pattern",
"=",
"pattern",
"compile",
"(",
"\"",
"firefox",
"/",
"\\",
"\\",
"d",
"+",
"\"",
")",
";",
"matcher",
"browser",
"matcher",
"=",
"browser",
"pattern",
"matcher",
"(",
"get",
"user",
"agent",
"(",
"driver",
")",
")",
";",
"if",
"(",
"!",
"browser",
"matcher",
"find",
"(",
")",
")",
"{",
"return",
"0",
";",
"}",
"string",
"browser",
"str",
"=",
"browser",
"matcher",
"group",
"(",
")",
";",
"/",
"/",
"extract",
"version",
"string",
"pattern",
"version",
"pattern",
"=",
"pattern",
"compile",
"(",
"\"",
"\\",
"\\",
"d",
"+",
"\"",
")",
";",
"matcher",
"version",
"matcher",
"=",
"version",
"pattern",
"matcher",
"(",
"browser",
"str",
")",
";",
"if",
"(",
"!",
"version",
"matcher",
"find",
"(",
")",
")",
"{",
"return",
"0",
";",
"}",
"return",
"integer",
"parse",
"int",
"(",
"version",
"matcher",
"group",
"(",
")",
")",
";",
"}"
] |
[
"create",
"new",
"ticket",
"granting",
"ticket"
] | [
"public",
"response",
"entity",
"<",
"string",
">",
"create",
"ticket",
"granting",
"ticket",
"(",
"@",
"request",
"body",
"final",
"multi",
"value",
"map",
"<",
"string",
",",
"string",
">",
"request",
"body",
",",
"final",
"http",
"servlet",
"request",
"request",
")",
"{",
"try",
"{",
"val",
"credential",
"=",
"this",
"credential",
"factory",
"from",
"request",
"(",
"request",
",",
"request",
"body",
")",
";",
"if",
"(",
"credential",
"=",
"=",
"null",
"|",
"|",
"credential",
"is",
"empty",
"(",
")",
")",
"{",
"throw",
"new",
"bad",
"rest",
"request",
"exception",
"(",
"\"",
"no",
"credentials",
"are",
"provided",
"or",
"extracted",
"to",
"authenticate",
"the",
"rest",
"request",
"\"",
")",
";",
"}",
"val",
"service",
"=",
"this",
"service",
"factory",
"create",
"service",
"(",
"request",
")",
";",
"val",
"authentication",
"result",
"=",
"authentication",
"system",
"support",
"handle",
"and",
"finalize",
"single",
"authentication",
"transaction",
"(",
"service",
",",
"credential",
")",
";",
"if",
"(",
"authentication",
"result",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"failed",
"login",
"exception",
"(",
"\"",
"authentication",
"failed",
"\"",
")",
";",
"}",
"return",
"this",
"user",
"authentication",
"resource",
"entity",
"response",
"factory",
"build",
"(",
"authentication",
"result",
",",
"request",
")",
";",
"}",
"catch",
"(",
"final",
"authentication",
"exception",
"e",
")",
"{",
"return",
"rest",
"resource",
"utils",
"create",
"response",
"entity",
"for",
"authn",
"failure",
"(",
"e",
",",
"request",
",",
"application",
"context",
")",
";",
"}",
"catch",
"(",
"final",
"bad",
"rest",
"request",
"exception",
"e",
")",
"{",
"logging",
"utils",
"error",
"(",
"logger",
",",
"e",
")",
";",
"return",
"new",
"response",
"entity",
"<",
">",
"(",
"e",
"get",
"message",
"(",
")",
",",
"http",
"status",
"bad",
"request",
")",
";",
"}",
"catch",
"(",
"final",
"exception",
"e",
")",
"{",
"logging",
"utils",
"error",
"(",
"logger",
",",
"e",
")",
";",
"return",
"new",
"response",
"entity",
"<",
">",
"(",
"e",
"get",
"message",
"(",
")",
",",
"http",
"status",
"internal",
"server",
"error",
")",
";",
"}",
"}"
] |
[
"returns",
"human",
"readable",
"string",
"representation",
"of",
"{",
"@",
"code",
"type",
"}",
"the",
"format",
"is",
"subject",
"to",
"change"
] | [
"static",
"string",
"to",
"string",
"(",
"type",
"type",
")",
"{",
"return",
"(",
"type",
"instanceof",
"class",
")",
"?",
"(",
"(",
"class",
"<",
"?",
">",
")",
"type",
")",
"get",
"name",
"(",
")",
":",
"type",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"returns",
"the",
"id",
"of",
"the",
"task",
"that",
"should",
"be",
"processed",
"by",
"default",
"tasks",
"with",
"any",
"ids",
"are",
"returned"
] | [
"public",
"task",
"id",
"get",
"task",
"id",
"(",
")",
"{",
"return",
"task",
"id",
";",
"}"
] |
[
"for",
"a",
"distance",
"as",
"returned",
"by",
"{",
"@",
"link",
"#",
"find",
"signed",
"distance",
"}",
",",
"returns",
"the",
"corresponding",
"\"",
"rgb",
"\"",
"(",
"really",
"argb",
")",
"color",
"value"
] | [
"private",
"int",
"distance",
"to",
"r",
"g",
"b",
"(",
"float",
"signed",
"distance",
")",
"{",
"float",
"alpha",
"=",
"0",
"5f",
"+",
"0",
"5f",
"*",
"(",
"signed",
"distance",
"/",
"spread",
")",
";",
"alpha",
"=",
"math",
"min",
"(",
"1",
",",
"math",
"max",
"(",
"0",
",",
"alpha",
")",
")",
";",
"/",
"/",
"compensate",
"for",
"rounding",
"errors",
"int",
"alpha",
"byte",
"=",
"(",
"int",
")",
"(",
"alpha",
"*",
"0x",
"f",
"f",
")",
";",
"/",
"/",
"no",
"unsigned",
"byte",
"in",
"java",
":",
"(",
"return",
"(",
"alpha",
"byte",
"<",
"<",
"24",
")",
"|",
"(",
"color",
"get",
"r",
"g",
"b",
"(",
")",
"&",
"0x",
"f",
"f",
"f",
"f",
"f",
"f",
")",
";",
"}"
] |
[
"model",
"tests",
"for",
"additional",
"properties",
"class"
] | [
"public",
"void",
"test",
"additional",
"properties",
"class",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"additional",
"properties",
"class",
"}"
] |
[
"configures",
"\"",
"com",
"google",
"devtools",
"build",
"\"",
"loggers",
"to",
"the",
"given",
"{",
"@",
"code",
"level",
"}"
] | [
"public",
"static",
"void",
"setup",
"logging",
"(",
"level",
"level",
")",
"{",
"if",
"(",
"!",
"level",
"equals",
"(",
"current",
"verbosity",
"level",
")",
")",
"{",
"template",
"logger",
"set",
"level",
"(",
"level",
")",
";",
"template",
"logger",
"info",
"(",
"\"",
"log",
"level",
":",
"\"",
"+",
"template",
"logger",
"get",
"level",
"(",
")",
")",
";",
"current",
"verbosity",
"level",
"=",
"level",
";",
"}",
"}"
] |
[
"creates",
"a",
"new",
"schema",
"but",
"drop",
"the",
"constraint",
"with",
"given",
"name"
] | [
"public",
"static",
"table",
"schema",
"drop",
"constraint",
"(",
"table",
"schema",
"ori",
"schema",
",",
"string",
"constraint",
"name",
")",
"{",
"/",
"/",
"validate",
"the",
"constraint",
"name",
"is",
"valid",
"optional",
"<",
"unique",
"constraint",
">",
"unique",
"constraint",
"opt",
"=",
"ori",
"schema",
"get",
"primary",
"key",
"(",
")",
";",
"if",
"(",
"!",
"unique",
"constraint",
"opt",
"is",
"present",
"(",
")",
"|",
"|",
"!",
"unique",
"constraint",
"opt",
"get",
"(",
")",
"get",
"name",
"(",
")",
"equals",
"(",
"constraint",
"name",
")",
")",
"{",
"throw",
"new",
"validation",
"exception",
"(",
"string",
"format",
"(",
"\"",
"constraint",
"%",
"s",
"to",
"drop",
"does",
"not",
"exist",
"\"",
",",
"constraint",
"name",
")",
")",
";",
"}",
"table",
"schema",
"builder",
"builder",
"=",
"builder",
"with",
"given",
"columns",
"(",
"ori",
"schema",
"get",
"table",
"columns",
"(",
")",
")",
";",
"/",
"/",
"copy",
"watermark",
"specification",
"for",
"(",
"watermark",
"spec",
"wms",
":",
"ori",
"schema",
"get",
"watermark",
"specs",
"(",
")",
")",
"{",
"builder",
"watermark",
"(",
"wms",
"get",
"rowtime",
"attribute",
"(",
")",
",",
"wms",
"get",
"watermark",
"expr",
"(",
")",
",",
"wms",
"get",
"watermark",
"expr",
"output",
"type",
"(",
")",
")",
";",
"}",
"return",
"builder",
"build",
"(",
")",
";",
"}"
] |
[
"add",
"to",
"the",
"list",
"of",
"indices",
"that",
"were",
"modified",
"by",
"this",
"request",
"this",
"is",
"the",
"list",
"of",
"indices",
"refreshed",
"at",
"the",
"end",
"of",
"the",
"request",
"if",
"the",
"request",
"asks",
"for",
"a",
"refresh"
] | [
"void",
"add",
"destination",
"indices",
"(",
"collection",
"<",
"string",
">",
"indices",
")",
"{",
"destination",
"indices",
"add",
"all",
"(",
"indices",
")",
";",
"}"
] |
[
"records",
"the",
"failed",
"load",
"of",
"a",
"new",
"entry",
"this",
"should",
"be",
"called",
"when",
"a",
"cache",
"request",
"causes",
"an",
"entry",
"to",
"be",
"loaded",
",",
"but",
"an",
"exception",
"is",
"thrown",
"while",
"loading",
"the",
"entry",
"in",
"contrast",
"to",
"{",
"@",
"link",
"#",
"record",
"misses",
"}",
",",
"this",
"method",
"should",
"only",
"be",
"called",
"by",
"the",
"loading",
"thread"
] | [
"void",
"record",
"load",
"exception",
"(",
"long",
"load",
"time",
")",
";"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.