docstring_tokens
list | code_tokens
list |
|---|---|
[
"merges",
"{",
"@",
"code",
"current",
"source",
"file",
"coverage",
"}",
"into",
"{",
"@",
"code",
"all",
"source",
"files",
"coverage",
"data",
"}",
"and",
"resets",
"{",
"@",
"code",
"current",
"source",
"file",
"coverage",
"}",
"to",
"null"
] |
[
"private",
"void",
"reset",
"(",
"list",
"<",
"source",
"file",
"coverage",
">",
"all",
"source",
"files",
")",
"{",
"all",
"source",
"files",
"add",
"(",
"current",
"source",
"file",
"coverage",
")",
";",
"current",
"source",
"file",
"coverage",
"=",
"null",
";",
"}"
] |
[
"sets",
"random",
"data",
"with",
"the",
"given",
"{",
"@",
"code",
"length",
"}",
"for",
"the",
"given",
"{",
"@",
"code",
"uri",
"}"
] |
[
"public",
"fake",
"data",
"set",
"set",
"random",
"data",
"(",
"string",
"uri",
",",
"int",
"length",
")",
"{",
"return",
"set",
"random",
"data",
"(",
"uri",
"parse",
"(",
"uri",
")",
",",
"length",
")",
";",
"}"
] |
[
"helper",
"method",
"to",
"generate",
"access",
"policy",
"for",
"the",
"storage",
"account",
"sas",
"key"
] |
[
"private",
"shared",
"access",
"account",
"policy",
"get",
"default",
"account",
"access",
"policy",
"(",
")",
"{",
"shared",
"access",
"account",
"policy",
"ap",
"=",
"new",
"shared",
"access",
"account",
"policy",
"(",
")",
";",
"calendar",
"cal",
"=",
"new",
"gregorian",
"calendar",
"(",
"time",
"zone",
"get",
"time",
"zone",
"(",
"\"",
"utc",
"\"",
")",
")",
";",
"cal",
"set",
"time",
"(",
"new",
"date",
"(",
")",
")",
";",
"cal",
"add",
"(",
"calendar",
"hour",
",",
"(",
"int",
")",
"get",
"sas",
"key",
"expiry",
"period",
"(",
")",
"*",
"hours",
"in",
"day",
")",
";",
"ap",
"set",
"shared",
"access",
"expiry",
"time",
"(",
"cal",
"get",
"time",
"(",
")",
")",
";",
"ap",
"set",
"permissions",
"(",
"get",
"default",
"accout",
"s",
"a",
"s",
"key",
"permissions",
"(",
")",
")",
";",
"ap",
"set",
"resource",
"types",
"(",
"enum",
"set",
"of",
"(",
"shared",
"access",
"account",
"resource",
"type",
"container",
",",
"shared",
"access",
"account",
"resource",
"type",
"object",
")",
")",
";",
"ap",
"set",
"services",
"(",
"enum",
"set",
"of",
"(",
"shared",
"access",
"account",
"service",
"blob",
")",
")",
";",
"return",
"ap",
";",
"}"
] |
[
"gets",
"the",
"offset",
"into",
"the",
"{",
"@",
"link",
"#",
"allocation",
"}",
"'",
"s",
"{",
"@",
"link",
"allocation",
"#",
"data",
"}",
"that",
"corresponds",
"to",
"the",
"specified",
"absolute",
"position"
] |
[
"public",
"int",
"translate",
"offset",
"(",
"long",
"absolute",
"position",
")",
"{",
"return",
"(",
"int",
")",
"(",
"absolute",
"position",
"-",
"start",
"position",
")",
"+",
"allocation",
"offset",
";",
"}"
] |
[
"common",
"method",
"for",
"testing",
"a",
"send",
"method",
"that",
"uses",
"the",
"message",
"creator",
"callback",
"but",
"with",
"different",
"qos",
"options"
] |
[
"private",
"void",
"do",
"test",
"send",
"destination",
"(",
"boolean",
"explicit",
"destination",
",",
"boolean",
"use",
"default",
"destination",
",",
"boolean",
"ignore",
"q",
"o",
"s",
",",
"boolean",
"disable",
"id",
"and",
"timestamp",
")",
"throws",
"exception",
"{",
"jms",
"template",
"template",
"=",
"create",
"template",
"(",
")",
";",
"template",
"set",
"connection",
"factory",
"(",
"this",
"connection",
"factory",
")",
";",
"string",
"destination",
"name",
"=",
"\"",
"test",
"destination",
"\"",
";",
"if",
"(",
"use",
"default",
"destination",
")",
"{",
"if",
"(",
"explicit",
"destination",
")",
"{",
"template",
"set",
"default",
"destination",
"(",
"this",
"queue",
")",
";",
"}",
"else",
"{",
"template",
"set",
"default",
"destination",
"name",
"(",
"destination",
"name",
")",
";",
"}",
"}",
"if",
"(",
"disable",
"id",
"and",
"timestamp",
")",
"{",
"template",
"set",
"message",
"id",
"enabled",
"(",
"false",
")",
";",
"template",
"set",
"message",
"timestamp",
"enabled",
"(",
"false",
")",
";",
"}",
"message",
"producer",
"message",
"producer",
"=",
"mock",
"(",
"message",
"producer",
"class",
")",
";",
"text",
"message",
"text",
"message",
"=",
"mock",
"(",
"text",
"message",
"class",
")",
";",
"given",
"(",
"this",
"session",
"create",
"producer",
"(",
"this",
"queue",
")",
")",
"will",
"return",
"(",
"message",
"producer",
")",
";",
"given",
"(",
"this",
"session",
"create",
"text",
"message",
"(",
"\"",
"just",
"testing",
"\"",
")",
")",
"will",
"return",
"(",
"text",
"message",
")",
";",
"if",
"(",
"!",
"ignore",
"q",
"o",
"s",
")",
"{",
"template",
"set",
"qos",
"settings",
"(",
"this",
"qos",
"settings",
")",
";",
"}",
"if",
"(",
"use",
"default",
"destination",
")",
"{",
"template",
"send",
"(",
"new",
"message",
"creator",
"(",
")",
"{",
"@",
"override",
"public",
"message",
"create",
"message",
"(",
"session",
"session",
")",
"throws",
"j",
"m",
"s",
"exception",
"{",
"return",
"session",
"create",
"text",
"message",
"(",
"\"",
"just",
"testing",
"\"",
")",
";",
"}",
"}",
")",
";",
"}",
"else",
"{",
"if",
"(",
"explicit",
"destination",
")",
"{",
"template",
"send",
"(",
"this",
"queue",
",",
"new",
"message",
"creator",
"(",
")",
"{",
"@",
"override",
"public",
"message",
"create",
"message",
"(",
"session",
"session",
")",
"throws",
"j",
"m",
"s",
"exception",
"{",
"return",
"session",
"create",
"text",
"message",
"(",
"\"",
"just",
"testing",
"\"",
")",
";",
"}",
"}",
")",
";",
"}",
"else",
"{",
"template",
"send",
"(",
"destination",
"name",
",",
"new",
"message",
"creator",
"(",
")",
"{",
"@",
"override",
"public",
"message",
"create",
"message",
"(",
"session",
"session",
")",
"throws",
"j",
"m",
"s",
"exception",
"{",
"return",
"session",
"create",
"text",
"message",
"(",
"\"",
"just",
"testing",
"\"",
")",
";",
"}",
"}",
")",
";",
"}",
"}",
"if",
"(",
"use",
"transacted",
"template",
"(",
")",
")",
"{",
"verify",
"(",
"this",
"session",
")",
"commit",
"(",
")",
";",
"}",
"if",
"(",
"disable",
"id",
"and",
"timestamp",
")",
"{",
"verify",
"(",
"message",
"producer",
")",
"set",
"disable",
"message",
"i",
"d",
"(",
"true",
")",
";",
"verify",
"(",
"message",
"producer",
")",
"set",
"disable",
"message",
"timestamp",
"(",
"true",
")",
";",
"}",
"if",
"(",
"ignore",
"q",
"o",
"s",
")",
"{",
"verify",
"(",
"message",
"producer",
")",
"send",
"(",
"text",
"message",
")",
";",
"}",
"else",
"{",
"verify",
"(",
"message",
"producer",
")",
"send",
"(",
"text",
"message",
",",
"this",
"qos",
"settings",
"get",
"delivery",
"mode",
"(",
")",
",",
"this",
"qos",
"settings",
"get",
"priority",
"(",
")",
",",
"this",
"qos",
"settings",
"get",
"time",
"to",
"live",
"(",
")",
")",
";",
"}",
"verify",
"(",
"message",
"producer",
")",
"close",
"(",
")",
";",
"verify",
"(",
"this",
"session",
")",
"close",
"(",
")",
";",
"verify",
"(",
"this",
"connection",
")",
"close",
"(",
")",
";",
"}"
] |
[
"change",
"branch",
"status",
"test"
] |
[
"public",
"void",
"change",
"branch",
"status",
"test",
"(",
"global",
"session",
"global",
"session",
",",
"branch",
"session",
"branch",
"session",
")",
"throws",
"exception",
"{",
"global",
"session",
"change",
"branch",
"status",
"(",
"branch",
"session",
",",
"branch",
"status",
"phase",
"two",
"committed",
")",
";",
"}"
] |
[
"copy",
"of",
"{",
"@",
"link",
"com",
"google",
"protobuf",
"util",
"timestamps",
"#",
"parse",
"nanos",
"}"
] |
[
"private",
"static",
"int",
"parse",
"nanos",
"(",
"string",
"value",
")",
"throws",
"parse",
"exception",
"{",
"int",
"result",
"=",
"0",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"9",
";",
"+",
"+",
"i",
")",
"{",
"result",
"=",
"result",
"*",
"10",
";",
"if",
"(",
"i",
"<",
"value",
"length",
"(",
")",
")",
"{",
"if",
"(",
"value",
"char",
"at",
"(",
"i",
")",
"<",
"'",
"0",
"'",
"|",
"|",
"value",
"char",
"at",
"(",
"i",
")",
">",
"'",
"9",
"'",
")",
"{",
"throw",
"new",
"parse",
"exception",
"(",
"\"",
"invalid",
"nanoseconds",
"\"",
",",
"0",
")",
";",
"}",
"result",
"+",
"=",
"value",
"char",
"at",
"(",
"i",
")",
"-",
"'",
"0",
"'",
";",
"}",
"}",
"return",
"result",
";",
"}"
] |
[
"define",
"a",
"new",
"configuration",
"with",
"no",
"special",
"validation",
"logic",
"and",
"no",
"custom",
"recommender"
] |
[
"public",
"config",
"def",
"define",
"(",
"string",
"name",
",",
"type",
"type",
",",
"object",
"default",
"value",
",",
"importance",
"importance",
",",
"string",
"documentation",
",",
"string",
"group",
",",
"int",
"order",
"in",
"group",
",",
"width",
"width",
",",
"string",
"display",
"name",
",",
"list",
"<",
"string",
">",
"dependents",
")",
"{",
"return",
"define",
"(",
"name",
",",
"type",
",",
"default",
"value",
",",
"null",
",",
"importance",
",",
"documentation",
",",
"group",
",",
"order",
"in",
"group",
",",
"width",
",",
"display",
"name",
",",
"dependents",
",",
"null",
")",
";",
"}"
] |
[
"whether",
"the",
"given",
"{",
"@",
"linkplain",
"method",
"parameter",
"method",
"return",
"type",
"}",
"is",
"supported",
"by",
"this",
"handler"
] |
[
"boolean",
"supports",
"return",
"type",
"(",
"method",
"parameter",
"return",
"type",
")",
";"
] |
[
"try",
"to",
"locate",
"a",
"table",
"index",
"that",
"can",
"lookup",
"results",
"by",
"indexable",
"columns",
"and",
"provide",
"the",
"requested",
"output",
"columns"
] |
[
"default",
"optional",
"<",
"connector",
"resolved",
"index",
">",
"resolve",
"index",
"(",
"connector",
"session",
"session",
",",
"connector",
"table",
"handle",
"table",
"handle",
",",
"set",
"<",
"column",
"handle",
">",
"indexable",
"columns",
",",
"set",
"<",
"column",
"handle",
">",
"output",
"columns",
",",
"tuple",
"domain",
"<",
"column",
"handle",
">",
"tuple",
"domain",
")",
"{",
"return",
"optional",
"empty",
"(",
")",
";",
"}"
] |
[
"visits",
"a",
"{",
"@",
"link",
"plain",
"insn",
"}"
] |
[
"public",
"void",
"visit",
"plain",
"insn",
"(",
"plain",
"insn",
"insn",
")",
";"
] |
[
"returns",
"a",
"{",
"@",
"link",
"collector",
"}",
"that",
"accumulates",
"elements",
"into",
"an",
"{",
"@",
"code",
"immutable",
"map",
"}",
"whose",
"keys",
"and",
"values",
"are",
"the",
"result",
"of",
"applying",
"the",
"provided",
"mapping",
"functions",
"to",
"the",
"input",
"elements",
"if",
"the",
"mapped",
"keys",
"contain",
"duplicates",
"(",
"according",
"to",
"{",
"@",
"link",
"object",
"#",
"equals",
"(",
"object",
")",
"}",
")",
",",
"the",
"values",
"are",
"merged",
"using",
"the",
"specified",
"merging",
"function",
"entries",
"will",
"appear",
"in",
"the",
"encounter",
"order",
"of",
"the",
"first",
"occurrence",
"of",
"the",
"key"
] |
[
"public",
"static",
"<",
"t",
",",
"k",
",",
"v",
">",
"collector",
"<",
"t",
",",
"?",
",",
"immutable",
"map",
"<",
"k",
",",
"v",
">",
">",
"to",
"immutable",
"map",
"(",
"function",
"<",
"?",
"super",
"t",
",",
"?",
"extends",
"k",
">",
"key",
"function",
",",
"function",
"<",
"?",
"super",
"t",
",",
"?",
"extends",
"v",
">",
"value",
"function",
",",
"binary",
"operator",
"<",
"v",
">",
"merge",
"function",
")",
"{",
"return",
"collect",
"collectors",
"to",
"immutable",
"map",
"(",
"key",
"function",
",",
"value",
"function",
",",
"merge",
"function",
")",
";",
"}"
] |
[
"write",
"measurement",
"point"
] |
[
"public",
"void",
"write",
"(",
"final",
"point",
"point",
")",
"{",
"this",
"influx",
"db",
"write",
"(",
"influx",
"db",
"properties",
"get",
"database",
"(",
")",
",",
"influx",
"db",
"properties",
"get",
"retention",
"policy",
"(",
")",
",",
"point",
")",
";",
"}"
] |
[
"get",
"the",
"current",
"motor",
"torque",
",",
"usually",
"in",
"n",
"-",
"m"
] |
[
"public",
"float",
"get",
"motor",
"torque",
"(",
"float",
"inv",
"dt",
")",
"{",
"return",
"joint",
"get",
"motor",
"torque",
"(",
"inv",
"dt",
")",
";",
"}"
] |
[
"get",
"name",
"integer"
] |
[
"public",
"integer",
"get",
"name",
"integer",
"(",
")",
"{",
"return",
"name",
"integer",
";",
"}"
] |
[
"returns",
"a",
"predicate",
"that",
"only",
"accepts",
"settings",
"of",
"nodes",
"with",
"one",
"of",
"the",
"given",
"names"
] |
[
"public",
"static",
"predicate",
"<",
"settings",
">",
"name",
"filter",
"(",
"string",
"node",
"names",
")",
"{",
"final",
"set",
"<",
"string",
">",
"nodes",
"=",
"sets",
"new",
"hash",
"set",
"(",
"node",
"names",
")",
";",
"return",
"settings",
"-",
">",
"nodes",
"contains",
"(",
"settings",
"get",
"(",
"\"",
"node",
"name",
"\"",
")",
")",
";",
"}"
] |
[
"the",
"size",
"of",
"the",
"payload",
"in",
"terms",
"of",
"bytes",
"applied",
"to",
"the",
"flow",
"-",
"control",
"window",
"some",
"payloads",
"like",
"{",
"@",
"code",
"header",
"}",
"frames",
"have",
"no",
"cost",
"against",
"flow",
"control",
"and",
"would",
"return",
"0",
"for",
"this",
"value",
"even",
"though",
"they",
"produce",
"a",
"non",
"-",
"zero",
"number",
"of",
"bytes",
"on",
"the",
"wire",
"other",
"frames",
"like",
"{",
"@",
"code",
"data",
"}",
"frames",
"have",
"both",
"their",
"payload",
"and",
"padding",
"count",
"against",
"flow",
"-",
"control"
] |
[
"int",
"size",
"(",
")",
";"
] |
[
"test",
"the",
"property",
"'",
"prefix",
"ns",
"boolean",
"'"
] |
[
"public",
"void",
"prefix",
"ns",
"boolean",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"prefix",
"ns",
"boolean",
"}"
] |
[
"cause",
"this",
"zoo",
"keeper",
"object",
"to",
"disconnect",
"from",
"the",
"server",
"it",
"will",
"then",
"later",
"attempt",
"to",
"reconnect"
] |
[
"public",
"void",
"testable",
"connloss",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"synchronized",
"(",
"cnxn",
")",
"{",
"cnxn",
"send",
"thread",
"testable",
"close",
"socket",
"(",
")",
";",
"}",
"}"
] |
[
"removes",
"an",
"actor",
"from",
"this",
"group",
"calls",
"{",
"@",
"link",
"#",
"remove",
"actor",
"at",
"(",
"int",
",",
"boolean",
")",
"}",
"with",
"the",
"actor",
"'",
"s",
"child",
"index"
] |
[
"public",
"boolean",
"remove",
"actor",
"(",
"actor",
"actor",
",",
"boolean",
"unfocus",
")",
"{",
"int",
"index",
"=",
"children",
"index",
"of",
"(",
"actor",
",",
"true",
")",
";",
"if",
"(",
"index",
"=",
"=",
"-",
"1",
")",
"return",
"false",
";",
"remove",
"actor",
"at",
"(",
"index",
",",
"unfocus",
")",
";",
"return",
"true",
";",
"}"
] |
[
"specify",
"the",
"topic",
"'",
"s",
"number",
"of",
"partition",
"should",
"be",
"the",
"broker",
"configuration",
"for",
"{",
"@",
"code",
"num",
"partitions",
"}"
] |
[
"public",
"new",
"topic",
"builder",
"default",
"partitions",
"(",
")",
"{",
"this",
"num",
"partitions",
"=",
"no",
"partitions",
";",
"return",
"this",
";",
"}"
] |
[
"load",
"bean",
"definitions",
"from",
"the",
"specified",
"properties",
"file"
] |
[
"public",
"int",
"load",
"bean",
"definitions",
"(",
"resource",
"resource",
",",
"@",
"nullable",
"string",
"prefix",
")",
"throws",
"bean",
"definition",
"store",
"exception",
"{",
"return",
"load",
"bean",
"definitions",
"(",
"new",
"encoded",
"resource",
"(",
"resource",
")",
",",
"prefix",
")",
";",
"}"
] |
[
"marks",
"the",
"current",
"position",
"in",
"this",
"input",
"stream",
"a",
"subsequent",
"call",
"to",
"the",
"{",
"@",
"code",
"reset",
"}",
"method",
"repositions",
"this",
"stream",
"at",
"the",
"last",
"marked",
"position",
"so",
"that",
"subsequent",
"reads",
"re",
"-",
"read",
"the",
"same",
"bytes",
"the",
"{",
"@",
"code",
"readlimit",
"}",
"arguments",
"tells",
"this",
"input",
"stream",
"to",
"allow",
"that",
"many",
"bytes",
"to",
"be",
"read",
"before",
"the",
"mark",
"position",
"can",
"be",
"invalidated",
"the",
"{",
"@",
"code",
"mark",
"}",
"call",
"is",
"forwarded",
"to",
"the",
"current",
"component",
"input",
"stream",
"and",
"a",
"reference",
"to",
"it",
"is",
"stored",
"internally"
] |
[
"public",
"void",
"mark",
"(",
"int",
"readlimit",
")",
"{",
"if",
"(",
"mark",
"supported",
"(",
")",
"&",
"&",
"false",
"=",
"=",
"closed",
")",
"{",
"/",
"/",
"closes",
"any",
"previously",
"stored",
"mark",
"input",
"stream",
"if",
"(",
"mark",
"in",
"!",
"=",
"null",
"&",
"&",
"mark",
"in",
"!",
"=",
"exhausted",
"marker",
"&",
"&",
"current",
"in",
"!",
"=",
"mark",
"in",
")",
"{",
"try",
"{",
"mark",
"in",
"close",
"(",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"/",
"/",
"an",
"i",
"o",
"exception",
"on",
"a",
"component",
"input",
"stream",
"close",
"is",
"not",
"important",
"logger",
"info",
"(",
"\"",
"i",
"o",
"exception",
"while",
"closing",
"a",
"marked",
"component",
"input",
"stream",
"during",
"a",
"mark",
"\"",
",",
"e",
")",
";",
"}",
"}",
"/",
"/",
"stores",
"the",
"current",
"input",
"stream",
"to",
"be",
"reused",
"in",
"case",
"of",
"a",
"reset",
"mark",
"in",
"=",
"current",
"in",
";",
"if",
"(",
"mark",
"in",
"!",
"=",
"null",
"&",
"&",
"mark",
"in",
"!",
"=",
"exhausted",
"marker",
")",
"{",
"mark",
"in",
"mark",
"(",
"readlimit",
")",
";",
"}",
"}",
"}"
] |
[
"build",
"an",
"{",
"@",
"link",
"aggregator",
"}",
"for",
"a",
"{",
"@",
"code",
"range",
"}",
"aggregation",
"if",
"the",
"{",
"@",
"code",
"ranges",
"}",
"can",
"be",
"converted",
"into",
"filters",
"then",
"it",
"builds",
"a",
"{",
"@",
"link",
"filters",
"aggregator",
"}",
"and",
"uses",
"that",
"to",
"collect",
"the",
"results",
"if",
"that",
"aggregator",
"can",
"run",
"in",
"\"",
"filter",
"by",
"filter",
"\"",
"collection",
"mode",
"if",
"it",
"can",
"'",
"t",
"then",
"we",
"'",
"ll",
"collect",
"the",
"ranges",
"using",
"a",
"native",
"{",
"@",
"link",
"range",
"aggregator",
"}",
"which",
"is",
"significantly",
"faster",
"than",
"the",
"\"",
"compatible",
"\"",
"collection",
"mechanism",
"for",
"the",
"filters",
"agg"
] |
[
"public",
"static",
"aggregator",
"build",
"(",
"string",
"name",
",",
"aggregator",
"factories",
"factories",
",",
"values",
"source",
"config",
"values",
"source",
"config",
",",
"internal",
"range",
"factory",
"<",
"?",
",",
"?",
">",
"range",
"factory",
",",
"range",
"[",
"]",
"ranges",
",",
"boolean",
"keyed",
",",
"aggregation",
"context",
"context",
",",
"aggregator",
"parent",
",",
"cardinality",
"upper",
"bound",
"cardinality",
",",
"map",
"<",
"string",
",",
"object",
">",
"metadata",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"*",
"*",
"estimate",
"the",
"average",
"number",
"of",
"docs",
"per",
"range",
"so",
"we",
"can",
"disable",
"the",
"*",
"filter",
"collection",
"mechanism",
"if",
"very",
"few",
"docs",
"would",
"match",
"this",
"estimate",
"*",
"doesn",
"'",
"t",
"take",
"the",
"top",
"level",
"query",
"or",
"deleted",
"documents",
"into",
"account",
"so",
"it",
"*",
"is",
"often",
"an",
"overestimate",
"but",
"that",
"is",
"ok",
"because",
"at",
"worst",
"we",
"end",
"up",
"*",
"wasting",
"a",
"couple",
"dozen",
"milliseconds",
"on",
"the",
"filters",
"if",
"the",
"index",
"is",
"*",
"small",
"-",
"ish",
"and",
"there",
"are",
"many",
"filters",
"then",
"we",
"avoid",
"the",
"optimization",
"*",
"which",
"is",
"good",
"enough",
"because",
"that",
"is",
"the",
"most",
"embarrassing",
"scenario",
"*",
"/",
"double",
"average",
"docs",
"per",
"range",
"=",
"(",
"(",
"double",
")",
"context",
"searcher",
"(",
")",
"get",
"index",
"reader",
"(",
")",
"max",
"doc",
"(",
")",
")",
"/",
"ranges",
"length",
";",
"from",
"filters",
"<",
"?",
">",
"adapted",
"=",
"adapt",
"into",
"filters",
"or",
"null",
"(",
"name",
",",
"factories",
",",
"values",
"source",
"config",
",",
"range",
"factory",
",",
"ranges",
",",
"average",
"docs",
"per",
"range",
",",
"keyed",
",",
"context",
",",
"parent",
",",
"cardinality",
",",
"metadata",
")",
";",
"map",
"<",
"string",
",",
"object",
">",
"filters",
"debug",
"=",
"null",
";",
"if",
"(",
"adapted",
"!",
"=",
"null",
")",
"{",
"long",
"max",
"estimated",
"filters",
"cost",
"=",
"context",
"searcher",
"(",
")",
"get",
"index",
"reader",
"(",
")",
"max",
"doc",
"(",
")",
";",
"long",
"estimated",
"filters",
"cost",
"=",
"adapted",
"estimate",
"cost",
"(",
"max",
"estimated",
"filters",
"cost",
")",
";",
"if",
"(",
"estimated",
"filters",
"cost",
"<",
"=",
"max",
"estimated",
"filters",
"cost",
")",
"{",
"return",
"adapted",
";",
"}",
"/",
"*",
"*",
"looks",
"like",
"it",
"'",
"d",
"be",
"more",
"expensive",
"to",
"use",
"the",
"filter",
"-",
"by",
"-",
"filter",
"*",
"aggregator",
"oh",
"well",
"snapshot",
"the",
"the",
"filter",
"-",
"by",
"-",
"filter",
"*",
"aggregator",
"'",
"s",
"debug",
"information",
"if",
"we",
"'",
"re",
"profiling",
"bececause",
"it",
"*",
"is",
"useful",
"even",
"if",
"the",
"aggregator",
"isn",
"'",
"t",
"*",
"/",
"if",
"(",
"context",
"profiling",
"(",
")",
")",
"{",
"filters",
"debug",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"adapted",
"delegate",
"(",
")",
"collect",
"debug",
"info",
"(",
"filters",
"debug",
":",
":",
"put",
")",
";",
"}",
"}",
"return",
"build",
"without",
"attempted",
"to",
"adapt",
"to",
"filters",
"(",
"name",
",",
"factories",
",",
"(",
"values",
"source",
"numeric",
")",
"values",
"source",
"config",
"get",
"values",
"source",
"(",
")",
",",
"values",
"source",
"config",
"format",
"(",
")",
",",
"range",
"factory",
",",
"ranges",
",",
"average",
"docs",
"per",
"range",
",",
"filters",
"debug",
",",
"keyed",
",",
"context",
",",
"parent",
",",
"cardinality",
",",
"metadata",
")",
";",
"}"
] |
[
"returns",
"the",
"value",
"from",
"the",
"given",
"{",
"@",
"link",
"supplier",
"}",
",",
"invoking",
"the",
"call",
"in",
"the",
"swing",
"thread",
"this",
"is",
"useful",
"when",
"you",
"may",
"have",
"values",
"that",
"are",
"being",
"changed",
"on",
"the",
"swing",
"thread",
"and",
"you",
"need",
"the",
"test",
"thread",
"to",
"see",
"the",
"changes"
] |
[
"public",
"static",
"<",
"t",
">",
"t",
"run",
"swing",
"(",
"supplier",
"<",
"t",
">",
"s",
")",
"{",
"atomic",
"reference",
"<",
"t",
">",
"ref",
"=",
"new",
"atomic",
"reference",
"<",
">",
"(",
")",
";",
"run",
"swing",
"(",
"(",
")",
"-",
">",
"ref",
"set",
"(",
"s",
"get",
"(",
")",
")",
")",
";",
"return",
"ref",
"get",
"(",
")",
";",
"}"
] |
[
"creates",
"an",
"action",
"that",
"packages",
"the",
"java",
"source",
"files",
"into",
"a",
"jar",
"if",
"{",
"@",
"code",
"gensrc",
"jar",
"}",
"is",
"non",
"-",
"null",
",",
"includes",
"the",
"contents",
"of",
"the",
"{",
"@",
"code",
"gensrc",
"jar",
"}",
"with",
"the",
"output",
"source",
"jar"
] |
[
"public",
"void",
"create",
"source",
"jar",
"action",
"(",
"artifact",
"output",
"jar",
",",
"@",
"nullable",
"artifact",
"gensrc",
"jar",
",",
"java",
"toolchain",
"provider",
"java",
"toolchain",
"provider",
")",
"{",
"java",
"target",
"attributes",
"attributes",
"=",
"get",
"attributes",
"(",
")",
";",
"nested",
"set",
"builder",
"<",
"artifact",
">",
"resource",
"jars",
"=",
"nested",
"set",
"builder",
"stable",
"order",
"(",
")",
";",
"resource",
"jars",
"add",
"all",
"(",
"attributes",
"get",
"source",
"jars",
"(",
")",
")",
";",
"if",
"(",
"gensrc",
"jar",
"!",
"=",
"null",
")",
"{",
"resource",
"jars",
"add",
"(",
"gensrc",
"jar",
")",
";",
"}",
"single",
"jar",
"action",
"builder",
"create",
"source",
"jar",
"action",
"(",
"rule",
"context",
",",
"rule",
"context",
",",
"semantics",
",",
"nested",
"set",
"builder",
"<",
"artifact",
">",
"wrap",
"(",
"order",
"stable",
"order",
",",
"attributes",
"get",
"source",
"files",
"(",
")",
")",
",",
"resource",
"jars",
"build",
"(",
")",
",",
"output",
"jar",
",",
"java",
"toolchain",
"provider",
")",
";",
"}"
] |
[
"send",
"the",
"given",
"array",
"of",
"java",
"mail",
"mime",
"messages",
"in",
"batch",
"the",
"messages",
"need",
"to",
"have",
"been",
"created",
"with",
"{",
"@",
"link",
"#",
"create",
"mime",
"message",
"(",
")",
"}"
] |
[
"void",
"send",
"(",
"mime",
"message",
"mime",
"messages",
")",
"throws",
"mail",
"exception",
";"
] |
[
"read",
"a",
"list",
"of",
"documents",
"from",
"{",
"@",
"link",
"document",
"store",
"vendor",
"}",
"backend",
"for",
"a",
"{",
"@",
"link",
"collection",
"type",
"}"
] |
[
"public",
"list",
"<",
"timeline",
"entity",
"document",
">",
"read",
"documents",
"(",
"timeline",
"reader",
"context",
"context",
",",
"long",
"documents",
"size",
")",
"throws",
"i",
"o",
"exception",
"{",
"list",
"<",
"timeline",
"entity",
"document",
">",
"entity",
"docs",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"log",
"debug",
"(",
"\"",
"fetching",
"documents",
"for",
"entity",
"type",
"{",
"}",
"\"",
",",
"context",
"get",
"entity",
"type",
"(",
")",
")",
";",
"switch",
"(",
"timeline",
"entity",
"type",
"value",
"of",
"(",
"context",
"get",
"entity",
"type",
"(",
")",
")",
")",
"{",
"case",
"yarn",
"application",
":",
"return",
"generic",
"entity",
"doc",
"reader",
"read",
"document",
"list",
"(",
"collection",
"type",
"application",
"get",
"collection",
"name",
"(",
")",
",",
"context",
",",
"timeline",
"entity",
"document",
"class",
",",
"documents",
"size",
")",
";",
"case",
"yarn",
"flow",
"run",
":",
"list",
"<",
"flow",
"run",
"document",
">",
"flow",
"run",
"docs",
"=",
"flow",
"run",
"doc",
"reader",
"read",
"document",
"list",
"(",
"collection",
"type",
"flow",
"run",
"get",
"collection",
"name",
"(",
")",
",",
"context",
",",
"flow",
"run",
"document",
"class",
",",
"documents",
"size",
")",
";",
"for",
"(",
"flow",
"run",
"document",
"flow",
"run",
"doc",
":",
"flow",
"run",
"docs",
")",
"{",
"entity",
"docs",
"add",
"(",
"new",
"timeline",
"entity",
"document",
"(",
"create",
"flow",
"run",
"entity",
"(",
"flow",
"run",
"doc",
")",
")",
")",
";",
"}",
"return",
"entity",
"docs",
";",
"case",
"yarn",
"flow",
"activity",
":",
"list",
"<",
"flow",
"activity",
"document",
">",
"flow",
"activity",
"docs",
"=",
"flow",
"activity",
"doc",
"reader",
"read",
"document",
"list",
"(",
"collection",
"type",
"flow",
"activity",
"get",
"collection",
"name",
"(",
")",
",",
"context",
",",
"flow",
"activity",
"document",
"class",
",",
"documents",
"size",
")",
";",
"for",
"(",
"flow",
"activity",
"document",
"flow",
"activity",
"doc",
":",
"flow",
"activity",
"docs",
")",
"{",
"entity",
"docs",
"add",
"(",
"new",
"timeline",
"entity",
"document",
"(",
"create",
"flow",
"activity",
"entity",
"(",
"context",
",",
"flow",
"activity",
"doc",
")",
")",
")",
";",
"}",
"return",
"entity",
"docs",
";",
"default",
":",
"return",
"generic",
"entity",
"doc",
"reader",
"read",
"document",
"list",
"(",
"collection",
"type",
"entity",
"get",
"collection",
"name",
"(",
")",
",",
"context",
",",
"timeline",
"entity",
"document",
"class",
",",
"documents",
"size",
")",
";",
"}",
"}"
] |
[
"test",
"to",
"verify",
"delete",
"fails",
"for",
"child",
"files",
"and",
"folders",
"when",
"non",
"-",
"owner",
"user",
"performs",
"delete",
"and",
"stickybit",
"is",
"set",
"on",
"parent"
] |
[
"public",
"void",
"test",
"recursive",
"delete",
"fails",
"with",
"stickybit",
"(",
")",
"throws",
"throwable",
"{",
"path",
"parent",
"dir",
"=",
"new",
"path",
"(",
"\"",
"/",
"test",
"recursive",
"delete",
"fails",
"with",
"stickybit",
"\"",
")",
";",
"path",
"child",
"dir",
"=",
"new",
"path",
"(",
"parent",
"dir",
",",
"\"",
"child",
"\"",
")",
";",
"path",
"test",
"file",
"path",
"=",
"new",
"path",
"(",
"child",
"dir",
",",
"\"",
"test",
"dat",
"\"",
")",
";",
"path",
"test",
"folder",
"path",
"=",
"new",
"path",
"(",
"child",
"dir",
",",
"\"",
"test",
"directory",
"\"",
")",
";",
"authorizer",
"add",
"auth",
"rule",
"for",
"owner",
"(",
"\"",
"/",
"\"",
",",
"write",
",",
"true",
")",
";",
"authorizer",
"add",
"auth",
"rule",
"for",
"owner",
"(",
"\"",
"/",
"test",
"recursive",
"delete",
"fails",
"with",
"stickybit",
"*",
"\"",
",",
"write",
",",
"true",
")",
";",
"fs",
"update",
"wasb",
"authorizer",
"(",
"authorizer",
")",
";",
"try",
"{",
"fs",
"create",
"(",
"test",
"file",
"path",
")",
";",
"contract",
"test",
"utils",
"assert",
"path",
"exists",
"(",
"fs",
",",
"\"",
"file",
"was",
"not",
"created",
"\"",
",",
"test",
"file",
"path",
")",
";",
"fs",
"mkdirs",
"(",
"test",
"folder",
"path",
")",
";",
"contract",
"test",
"utils",
"assert",
"path",
"exists",
"(",
"fs",
",",
"\"",
"folder",
"was",
"not",
"created",
"\"",
",",
"test",
"folder",
"path",
")",
";",
"/",
"/",
"set",
"stickybit",
"on",
"child",
"directory",
"fs",
"set",
"permission",
"(",
"new",
"path",
"(",
"parent",
"dir",
",",
"\"",
"child",
"\"",
")",
",",
"new",
"fs",
"permission",
"(",
"stickybit",
"permission",
"constant",
")",
")",
";",
"user",
"group",
"information",
"dummy",
"user",
"=",
"user",
"group",
"information",
"create",
"user",
"for",
"testing",
"(",
"\"",
"dummy",
"user",
"\"",
",",
"new",
"string",
"[",
"]",
"{",
"\"",
"dummygroup",
"\"",
"}",
")",
";",
"dummy",
"user",
"do",
"as",
"(",
"new",
"privileged",
"exception",
"action",
"<",
"void",
">",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"run",
"(",
")",
"throws",
"exception",
"{",
"/",
"/",
"add",
"auth",
"rules",
"for",
"dummyuser",
"authorizer",
"add",
"auth",
"rule",
"(",
"\"",
"/",
"\"",
",",
"write",
",",
"get",
"current",
"user",
"short",
"name",
"(",
")",
",",
"true",
")",
";",
"authorizer",
"add",
"auth",
"rule",
"(",
"\"",
"/",
"test",
"recursive",
"delete",
"fails",
"with",
"stickybit",
"*",
"\"",
",",
"write",
",",
"get",
"current",
"user",
"short",
"name",
"(",
")",
",",
"true",
")",
";",
"assert",
"false",
"(",
"fs",
"delete",
"(",
"parent",
"dir",
",",
"true",
")",
")",
";",
"return",
"null",
";",
"}",
"}",
")",
";",
"contract",
"test",
"utils",
"assert",
"path",
"exists",
"(",
"fs",
",",
"\"",
"parent",
"dir",
"is",
"deleted",
"!",
"\"",
",",
"parent",
"dir",
")",
";",
"contract",
"test",
"utils",
"assert",
"path",
"exists",
"(",
"fs",
",",
"\"",
"file",
"is",
"deleted",
"!",
"\"",
",",
"test",
"file",
"path",
")",
";",
"contract",
"test",
"utils",
"assert",
"path",
"exists",
"(",
"fs",
",",
"\"",
"folder",
"is",
"deleted",
"!",
"\"",
",",
"test",
"folder",
"path",
")",
";",
"}",
"finally",
"{",
"allow",
"recursive",
"delete",
"(",
"fs",
",",
"parent",
"dir",
"to",
"string",
"(",
")",
")",
";",
"fs",
"delete",
"(",
"parent",
"dir",
",",
"true",
")",
";",
"}",
"}"
] |
[
"test",
"inline",
"additional",
"properties"
] |
[
"public",
"void",
"test",
"inline",
"additional",
"properties",
"(",
"@",
"valid",
"map",
"<",
"string",
",",
"string",
">",
"param",
")",
";"
] |
[
"returns",
"the",
"name",
"of",
"the",
"resource"
] |
[
"public",
"string",
"get",
"name",
"(",
")",
"{",
"return",
"name",
";",
"}"
] |
[
"returns",
"explicitly",
"listed",
"header",
"files"
] |
[
"public",
"nested",
"set",
"<",
"artifact",
">",
"get",
"declared",
"include",
"srcs",
"(",
")",
"{",
"return",
"cc",
"compilation",
"context",
"get",
"declared",
"include",
"srcs",
"(",
")",
";",
"}"
] |
[
"get",
"petfind",
"by",
"status"
] |
[
"public",
"<",
"t",
">",
"t",
"execute",
"(",
"function",
"<",
"response",
",",
"t",
">",
"handler",
")",
"{",
"return",
"handler",
"apply",
"(",
"rest",
"assured",
"given",
"(",
")",
"spec",
"(",
"req",
"spec",
"build",
"(",
")",
")",
"expect",
"(",
")",
"spec",
"(",
"resp",
"spec",
"build",
"(",
")",
")",
"when",
"(",
")",
"request",
"(",
"req",
"method",
",",
"req",
"uri",
")",
")",
";",
"}"
] |
[
"get",
"the",
"delegation",
"token",
"binding",
"for",
"this",
"test",
"suite"
] |
[
"protected",
"string",
"get",
"delegation",
"binding",
"(",
")",
"{",
"return",
"delegation",
"token",
"session",
"binding",
";",
"}"
] |
[
"checks",
"whether",
"the",
"provided",
"status",
"contains",
"a",
"specified",
"flag"
] |
[
"public",
"static",
"boolean",
"status",
"has",
"flag",
"(",
"@",
"status",
"int",
"status",
",",
"@",
"status",
"int",
"flag",
")",
"{",
"return",
"(",
"status",
"&",
"flag",
")",
"=",
"=",
"flag",
";",
"}"
] |
[
"gets",
"all",
"the",
"files",
"corresponding",
"to",
"the",
"config",
"temp",
"dirs"
] |
[
"file",
"[",
"]",
"get",
"paths",
"(",
")",
";"
] |
[
"returns",
"a",
"string",
"representation",
"of",
"the",
"builder",
"(",
"only",
"applicable",
"for",
"text",
"based",
"xcontent",
")"
] |
[
"public",
"static",
"string",
"to",
"string",
"(",
"x",
"content",
"builder",
"x",
"content",
"builder",
")",
"{",
"return",
"bytes",
"reference",
"bytes",
"(",
"x",
"content",
"builder",
")",
"utf",
"8",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"set",
"a",
"selection",
"listener",
"for",
"the",
"chart"
] |
[
"public",
"void",
"set",
"on",
"chart",
"value",
"selected",
"listener",
"(",
"on",
"chart",
"value",
"selected",
"listener",
"l",
")",
"{",
"this",
"m",
"selection",
"listener",
"=",
"l",
";",
"}"
] |
[
"returns",
"a",
"duplicated",
"buffer",
"that",
"shares",
"its",
"content",
"with",
"this",
"buffer",
"the",
"duplicated",
"buffer",
"'",
"s",
"position",
",",
"limit",
",",
"capacity",
"and",
"mark",
"are",
"the",
"same",
"as",
"this",
"buffer",
"the",
"duplicated",
"buffer",
"'",
"s",
"read",
"-",
"only",
"property",
"and",
"byte",
"order",
"are",
"same",
"as",
"this",
"buffer",
"'",
"s",
",",
"too",
"the",
"new",
"buffer",
"shares",
"its",
"content",
"with",
"this",
"buffer",
",",
"which",
"means",
"either",
"buffer",
"'",
"s",
"change",
"of",
"content",
"will",
"be",
"visible",
"to",
"the",
"other",
"the",
"two",
"buffer",
"'",
"s",
"position",
",",
"limit",
"and",
"mark",
"are",
"independent"
] |
[
"public",
"abstract",
"long",
"buffer",
"duplicate",
"(",
")",
";"
] |
[
"called",
"when",
"the",
"writability",
"of",
"the",
"underlying",
"channel",
"changes"
] |
[
"void",
"channel",
"writability",
"change",
"(",
")",
"throws",
"http",
"2",
"exception",
"{",
"}"
] |
[
"applies",
"the",
"given",
"window",
"function",
"to",
"each",
"window",
"the",
"window",
"function",
"is",
"called",
"for",
"each",
"evaluation",
"of",
"the",
"window",
"for",
"each",
"key",
"individually",
"the",
"output",
"of",
"the",
"window",
"function",
"is",
"interpreted",
"as",
"a",
"regular",
"non",
"-",
"windowed",
"stream",
"arriving",
"data",
"is",
"incrementally",
"aggregated",
"using",
"the",
"given",
"reducer"
] |
[
"public",
"<",
"r",
">",
"single",
"output",
"stream",
"operator",
"<",
"r",
">",
"apply",
"(",
"reduce",
"function",
"<",
"t",
">",
"reduce",
"function",
",",
"all",
"window",
"function",
"<",
"t",
",",
"r",
",",
"w",
">",
"function",
",",
"type",
"information",
"<",
"r",
">",
"result",
"type",
")",
"{",
"if",
"(",
"reduce",
"function",
"instanceof",
"rich",
"function",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
"\"",
"reduce",
"function",
"of",
"apply",
"can",
"not",
"be",
"a",
"rich",
"function",
"\"",
")",
";",
"}",
"/",
"/",
"clean",
"the",
"closures",
"function",
"=",
"input",
"get",
"execution",
"environment",
"(",
")",
"clean",
"(",
"function",
")",
";",
"reduce",
"function",
"=",
"input",
"get",
"execution",
"environment",
"(",
")",
"clean",
"(",
"reduce",
"function",
")",
";",
"string",
"call",
"location",
"=",
"utils",
"get",
"call",
"location",
"name",
"(",
")",
";",
"string",
"udf",
"name",
"=",
"\"",
"all",
"windowed",
"stream",
"\"",
"+",
"call",
"location",
";",
"string",
"op",
"name",
";",
"key",
"selector",
"<",
"t",
",",
"byte",
">",
"key",
"sel",
"=",
"input",
"get",
"key",
"selector",
"(",
")",
";",
"one",
"input",
"stream",
"operator",
"<",
"t",
",",
"r",
">",
"operator",
";",
"if",
"(",
"evictor",
"!",
"=",
"null",
")",
"{",
"@",
"suppress",
"warnings",
"(",
"{",
"\"",
"unchecked",
"\"",
",",
"\"",
"rawtypes",
"\"",
"}",
")",
"type",
"serializer",
"<",
"stream",
"record",
"<",
"t",
">",
">",
"stream",
"record",
"serializer",
"=",
"(",
"type",
"serializer",
"<",
"stream",
"record",
"<",
"t",
">",
">",
")",
"new",
"stream",
"element",
"serializer",
"(",
"input",
"get",
"type",
"(",
")",
"create",
"serializer",
"(",
"get",
"execution",
"environment",
"(",
")",
"get",
"config",
"(",
")",
")",
")",
";",
"list",
"state",
"descriptor",
"<",
"stream",
"record",
"<",
"t",
">",
">",
"state",
"desc",
"=",
"new",
"list",
"state",
"descriptor",
"<",
">",
"(",
"\"",
"window",
"-",
"contents",
"\"",
",",
"stream",
"record",
"serializer",
")",
";",
"op",
"name",
"=",
"\"",
"trigger",
"window",
"(",
"\"",
"+",
"window",
"assigner",
"+",
"\"",
",",
"\"",
"+",
"state",
"desc",
"+",
"\"",
",",
"\"",
"+",
"trigger",
"+",
"\"",
",",
"\"",
"+",
"evictor",
"+",
"\"",
",",
"\"",
"+",
"udf",
"name",
"+",
"\"",
")",
"\"",
";",
"operator",
"=",
"new",
"evicting",
"window",
"operator",
"<",
">",
"(",
"window",
"assigner",
",",
"window",
"assigner",
"get",
"window",
"serializer",
"(",
"get",
"execution",
"environment",
"(",
")",
"get",
"config",
"(",
")",
")",
",",
"key",
"sel",
",",
"input",
"get",
"key",
"type",
"(",
")",
"create",
"serializer",
"(",
"get",
"execution",
"environment",
"(",
")",
"get",
"config",
"(",
")",
")",
",",
"state",
"desc",
",",
"new",
"internal",
"iterable",
"all",
"window",
"function",
"<",
">",
"(",
"new",
"reduce",
"apply",
"all",
"window",
"function",
"<",
">",
"(",
"reduce",
"function",
",",
"function",
")",
")",
",",
"trigger",
",",
"evictor",
",",
"allowed",
"lateness",
",",
"late",
"data",
"output",
"tag",
")",
";",
"}",
"else",
"{",
"reducing",
"state",
"descriptor",
"<",
"t",
">",
"state",
"desc",
"=",
"new",
"reducing",
"state",
"descriptor",
"<",
">",
"(",
"\"",
"window",
"-",
"contents",
"\"",
",",
"reduce",
"function",
",",
"input",
"get",
"type",
"(",
")",
"create",
"serializer",
"(",
"get",
"execution",
"environment",
"(",
")",
"get",
"config",
"(",
")",
")",
")",
";",
"op",
"name",
"=",
"\"",
"trigger",
"window",
"(",
"\"",
"+",
"window",
"assigner",
"+",
"\"",
",",
"\"",
"+",
"state",
"desc",
"+",
"\"",
",",
"\"",
"+",
"trigger",
"+",
"\"",
",",
"\"",
"+",
"udf",
"name",
"+",
"\"",
")",
"\"",
";",
"operator",
"=",
"new",
"window",
"operator",
"<",
">",
"(",
"window",
"assigner",
",",
"window",
"assigner",
"get",
"window",
"serializer",
"(",
"get",
"execution",
"environment",
"(",
")",
"get",
"config",
"(",
")",
")",
",",
"key",
"sel",
",",
"input",
"get",
"key",
"type",
"(",
")",
"create",
"serializer",
"(",
"get",
"execution",
"environment",
"(",
")",
"get",
"config",
"(",
")",
")",
",",
"state",
"desc",
",",
"new",
"internal",
"single",
"value",
"all",
"window",
"function",
"<",
">",
"(",
"function",
")",
",",
"trigger",
",",
"allowed",
"lateness",
",",
"late",
"data",
"output",
"tag",
")",
";",
"}",
"return",
"input",
"transform",
"(",
"op",
"name",
",",
"result",
"type",
",",
"operator",
")",
"force",
"non",
"parallel",
"(",
")",
";",
"}"
] |
[
"return",
"the",
"jca",
"message",
"endpoint",
"factory",
"to",
"activate"
] |
[
"public",
"message",
"endpoint",
"factory",
"get",
"message",
"endpoint",
"factory",
"(",
")",
"{",
"return",
"this",
"message",
"endpoint",
"factory",
";",
"}"
] |
[
"can",
"the",
"given",
"advisor",
"apply",
"at",
"all",
"on",
"the",
"given",
"class",
"?",
"this",
"is",
"an",
"important",
"test",
"as",
"it",
"can",
"be",
"used",
"to",
"optimize",
"out",
"a",
"advisor",
"for",
"a",
"class",
"this",
"version",
"also",
"takes",
"into",
"account",
"introductions",
"(",
"for",
"introduction",
"aware",
"method",
"matchers",
")"
] |
[
"public",
"static",
"boolean",
"can",
"apply",
"(",
"advisor",
"advisor",
",",
"class",
"<",
"?",
">",
"target",
"class",
",",
"boolean",
"has",
"introductions",
")",
"{",
"if",
"(",
"advisor",
"instanceof",
"introduction",
"advisor",
")",
"{",
"return",
"(",
"(",
"introduction",
"advisor",
")",
"advisor",
")",
"get",
"class",
"filter",
"(",
")",
"matches",
"(",
"target",
"class",
")",
";",
"}",
"else",
"if",
"(",
"advisor",
"instanceof",
"pointcut",
"advisor",
")",
"{",
"pointcut",
"advisor",
"pca",
"=",
"(",
"pointcut",
"advisor",
")",
"advisor",
";",
"return",
"can",
"apply",
"(",
"pca",
"get",
"pointcut",
"(",
")",
",",
"target",
"class",
",",
"has",
"introductions",
")",
";",
"}",
"else",
"{",
"/",
"/",
"it",
"doesn",
"'",
"t",
"have",
"a",
"pointcut",
"so",
"we",
"assume",
"it",
"applies",
"return",
"true",
";",
"}",
"}"
] |
[
"refresh",
"object",
"in",
"ui"
] |
[
"public",
"static",
"void",
"fire",
"object",
"refresh",
"(",
"d",
"b",
"s",
"object",
"object",
")",
"{",
"/",
"/",
"select",
"with",
"true",
"parameter",
"is",
"the",
"same",
"as",
"refresh",
"fire",
"object",
"select",
"(",
"object",
",",
"true",
")",
";",
"}"
] |
[
"increase",
"the",
"sampling",
"factor",
"by",
"force",
",",
"to",
"avoid",
"sampling",
"too",
"many",
"traces",
"if",
"many",
"distributed",
"traces",
"require",
"sampled",
",",
"the",
"trace",
"beginning",
"at",
"local",
",",
"has",
"less",
"chance",
"to",
"be",
"sampled"
] |
[
"public",
"void",
"force",
"sampled",
"(",
")",
"{",
"if",
"(",
"on",
")",
"{",
"sampling",
"factor",
"holder",
"increment",
"and",
"get",
"(",
")",
";",
"}",
"}"
] |
[
"the",
"key",
"provider",
"uri",
"is",
"searched",
"in",
"the",
"following",
"order",
"1",
"if",
"there",
"is",
"a",
"mapping",
"in",
"credential",
"'",
"s",
"secrets",
"map",
"for",
"namenode",
"uri",
"2",
"from",
"namenode",
"get",
"server",
"defaults",
"call",
"3",
"finally",
"fallback",
"to",
"local",
"conf"
] |
[
"public",
"static",
"uri",
"get",
"key",
"provider",
"uri",
"(",
"user",
"group",
"information",
"ugi",
",",
"uri",
"namenode",
"uri",
",",
"string",
"key",
"provider",
"uri",
"str",
",",
"configuration",
"conf",
")",
"throws",
"i",
"o",
"exception",
"{",
"uri",
"key",
"provider",
"uri",
"=",
"null",
";",
"/",
"/",
"lookup",
"the",
"secret",
"in",
"credentials",
"object",
"for",
"namenodeuri",
"credentials",
"credentials",
"=",
"ugi",
"get",
"credentials",
"(",
")",
";",
"text",
"creds",
"key",
"=",
"get",
"key",
"provider",
"map",
"key",
"(",
"namenode",
"uri",
")",
";",
"byte",
"[",
"]",
"key",
"provider",
"uri",
"bytes",
"=",
"credentials",
"get",
"secret",
"key",
"(",
"creds",
"key",
")",
";",
"if",
"(",
"key",
"provider",
"uri",
"bytes",
"!",
"=",
"null",
")",
"{",
"key",
"provider",
"uri",
"=",
"uri",
"create",
"(",
"d",
"f",
"s",
"util",
"client",
"bytes",
"2",
"string",
"(",
"key",
"provider",
"uri",
"bytes",
")",
")",
";",
"}",
"if",
"(",
"key",
"provider",
"uri",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"check",
"if",
"nn",
"provided",
"uri",
"is",
"not",
"null",
"and",
"ignore",
"property",
"is",
"false",
"if",
"(",
"key",
"provider",
"uri",
"str",
"!",
"=",
"null",
"&",
"&",
"!",
"conf",
"get",
"boolean",
"(",
"dfs",
"client",
"ignore",
"namenode",
"default",
"kms",
"uri",
",",
"dfs",
"client",
"ignore",
"namenode",
"default",
"kms",
"uri",
"default",
")",
")",
"{",
"if",
"(",
"!",
"key",
"provider",
"uri",
"str",
"is",
"empty",
"(",
")",
")",
"{",
"key",
"provider",
"uri",
"=",
"uri",
"create",
"(",
"key",
"provider",
"uri",
"str",
")",
";",
"}",
"}",
"/",
"/",
"fallback",
"to",
"configuration",
"if",
"(",
"key",
"provider",
"uri",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"either",
"nn",
"is",
"old",
"and",
"doesn",
"'",
"t",
"report",
"provider",
"or",
"ignore",
"nn",
"kms",
"/",
"/",
"provider",
"property",
"is",
"set",
"to",
"true",
",",
"so",
"use",
"conf",
"key",
"provider",
"uri",
"=",
"k",
"m",
"s",
"util",
"get",
"key",
"provider",
"uri",
"(",
"conf",
",",
"key",
"provider",
"uri",
"key",
"name",
")",
";",
"}",
"if",
"(",
"key",
"provider",
"uri",
"!",
"=",
"null",
")",
"{",
"credentials",
"add",
"secret",
"key",
"(",
"creds",
"key",
",",
"d",
"f",
"s",
"util",
"client",
"string",
"2",
"bytes",
"(",
"key",
"provider",
"uri",
"to",
"string",
"(",
")",
")",
")",
";",
"}",
"}",
"return",
"key",
"provider",
"uri",
";",
"}"
] |
[
"continues",
"to",
"fetch",
"the",
"chunks",
"from",
"the",
"input"
] |
[
"public",
"void",
"resume",
"transfer",
"(",
")",
"{",
"final",
"channel",
"handler",
"context",
"ctx",
"=",
"this",
"ctx",
";",
"if",
"(",
"ctx",
"=",
"=",
"null",
")",
"{",
"return",
";",
"}",
"if",
"(",
"ctx",
"executor",
"(",
")",
"in",
"event",
"loop",
"(",
")",
")",
"{",
"resume",
"transfer",
"0",
"(",
"ctx",
")",
";",
"}",
"else",
"{",
"/",
"/",
"let",
"the",
"transfer",
"resume",
"on",
"the",
"next",
"event",
"loop",
"round",
"ctx",
"executor",
"(",
")",
"execute",
"(",
"new",
"runnable",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"run",
"(",
")",
"{",
"resume",
"transfer",
"0",
"(",
"ctx",
")",
";",
"}",
"}",
")",
";",
"}",
"}"
] |
[
"executes",
"the",
"test"
] |
[
"public",
"final",
"void",
"test",
"(",
")",
"{",
"try",
"{",
"recurse",
"(",
"0",
")",
";",
"}",
"catch",
"(",
"runtime",
"exception",
"e",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"arrays",
"to",
"string",
"(",
"stimuli",
")",
",",
"e",
")",
";",
"}",
"}"
] |
[
"test",
"the",
"property",
"'",
"kind",
"'"
] |
[
"public",
"void",
"kind",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"kind",
"}"
] |
[
"calls",
"{",
"@",
"link",
"channel",
"handler",
"context",
"#",
"fire",
"user",
"event",
"triggered",
"(",
"object",
")",
"}",
"to",
"forward",
"to",
"the",
"next",
"{",
"@",
"link",
"channel",
"inbound",
"handler",
"}",
"in",
"the",
"{",
"@",
"link",
"channel",
"pipeline",
"}",
"sub",
"-",
"classes",
"may",
"override",
"this",
"method",
"to",
"change",
"behavior"
] |
[
"public",
"void",
"user",
"event",
"triggered",
"(",
"channel",
"handler",
"context",
"ctx",
",",
"object",
"evt",
")",
"throws",
"exception",
"{",
"ctx",
"fire",
"user",
"event",
"triggered",
"(",
"evt",
")",
";",
"}"
] |
[
"a",
"test",
"where",
"the",
"blob",
"cache",
"must",
"use",
"the",
"blob",
"server",
"and",
"the",
"connection",
"fails",
"twice",
"and",
"then",
"the",
"get",
"operation",
"succeeds"
] |
[
"private",
"static",
"void",
"test",
"blob",
"fetch",
"retries",
"(",
"final",
"configuration",
"config",
",",
"final",
"blob",
"store",
"blob",
"store",
",",
"@",
"nullable",
"final",
"job",
"i",
"d",
"job",
"id",
",",
"blob",
"key",
"blob",
"type",
"blob",
"type",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"byte",
"[",
"]",
"data",
"=",
"new",
"byte",
"[",
"]",
"{",
"1",
",",
"2",
",",
"3",
",",
"4",
",",
"5",
",",
"6",
",",
"7",
",",
"8",
",",
"9",
",",
"0",
"}",
";",
"try",
"(",
"blob",
"server",
"server",
"=",
"new",
"testing",
"failing",
"blob",
"server",
"(",
"config",
",",
"blob",
"store",
",",
"2",
")",
";",
"blob",
"cache",
"service",
"cache",
"=",
"new",
"blob",
"cache",
"service",
"(",
"config",
",",
"new",
"void",
"blob",
"store",
"(",
")",
",",
"new",
"inet",
"socket",
"address",
"(",
"\"",
"localhost",
"\"",
",",
"server",
"get",
"port",
"(",
")",
")",
")",
")",
"{",
"server",
"start",
"(",
")",
";",
"/",
"/",
"upload",
"some",
"blob",
"final",
"blob",
"key",
"key",
"=",
"put",
"(",
"server",
",",
"job",
"id",
",",
"data",
",",
"blob",
"type",
")",
";",
"/",
"/",
"trigger",
"a",
"download",
"-",
"it",
"should",
"fail",
"the",
"first",
"two",
"times",
",",
"but",
"retry",
",",
"and",
"succeed",
"/",
"/",
"eventually",
"verify",
"contents",
"(",
"cache",
",",
"job",
"id",
",",
"key",
",",
"data",
")",
";",
"}",
"}"
] |
[
"the",
"amount",
"of",
"distortion",
"to",
"apply",
",",
"with",
"a",
"minimum",
"of",
"0",
"0",
"and",
"a",
"default",
"of",
"1",
"0"
] |
[
"public",
"void",
"set",
"angle",
"(",
"float",
"angle",
")",
"{",
"this",
"angle",
"=",
"angle",
";",
"set",
"float",
"(",
"angle",
"location",
",",
"angle",
")",
";",
"}"
] |
[
"add",
"a",
"comparator",
"to",
"the",
"end",
"of",
"the",
"chain",
"using",
"the",
"provided",
"sort",
"order"
] |
[
"public",
"void",
"add",
"comparator",
"(",
"comparator",
"<",
"?",
"extends",
"t",
">",
"comparator",
",",
"boolean",
"ascending",
")",
"{",
"this",
"comparators",
"add",
"(",
"new",
"invertible",
"comparator",
"(",
"comparator",
",",
"ascending",
")",
")",
";",
"}"
] |
[
"returns",
"an",
"unmodifiable",
"<",
"b",
">",
"view",
"<",
"b",
">",
"of",
"the",
"intersection",
"of",
"two",
"sets",
"the",
"returned",
"set",
"contains",
"all",
"elements",
"that",
"are",
"contained",
"by",
"both",
"backing",
"sets",
"the",
"iteration",
"order",
"of",
"the",
"returned",
"set",
"matches",
"that",
"of",
"{",
"@",
"code",
"set",
"1",
"}",
"results",
"are",
"undefined",
"if",
"{",
"@",
"code",
"set",
"1",
"}",
"and",
"{",
"@",
"code",
"set",
"2",
"}",
"are",
"sets",
"based",
"on",
"different",
"equivalence",
"relations",
"(",
"as",
"{",
"@",
"code",
"hash",
"set",
"}",
",",
"{",
"@",
"code",
"tree",
"set",
"}",
",",
"and",
"the",
"key",
"set",
"of",
"an",
"{",
"@",
"code",
"identity",
"hash",
"map",
"}",
"all",
"are",
")",
"<",
"b",
">",
"note",
":",
"<",
"b",
">",
"the",
"returned",
"view",
"performs",
"slightly",
"better",
"when",
"{",
"@",
"code",
"set",
"1",
"}",
"is",
"the",
"smaller",
"of",
"the",
"two",
"sets",
"if",
"you",
"have",
"reason",
"to",
"believe",
"one",
"of",
"your",
"sets",
"will",
"generally",
"be",
"smaller",
"than",
"the",
"other",
",",
"pass",
"it",
"first",
"unfortunately",
",",
"since",
"this",
"method",
"sets",
"the",
"generic",
"type",
"of",
"the",
"returned",
"set",
"based",
"on",
"the",
"type",
"of",
"the",
"first",
"set",
"passed",
",",
"this",
"could",
"in",
"rare",
"cases",
"force",
"you",
"to",
"make",
"a",
"cast",
",",
"for",
"example",
":",
"{",
"@",
"code",
"set",
"<",
"object",
">",
"a",
"few",
"bad",
"objects",
"=",
"set",
"<",
"string",
">",
"many",
"bad",
"strings",
"=",
"impossible",
"for",
"a",
"non",
"-",
"string",
"to",
"be",
"in",
"the",
"intersection",
"suppress",
"warnings",
"(",
"\"",
"unchecked",
"\"",
")",
"set",
"<",
"string",
">",
"bad",
"strings",
"=",
"(",
"set",
")",
"sets",
"intersection",
"(",
"a",
"few",
"bad",
"objects",
",",
"many",
"bad",
"strings",
")",
";",
"}",
"this",
"is",
"unfortunate",
",",
"but",
"should",
"come",
"up",
"only",
"very",
"rarely"
] |
[
"public",
"static",
"<",
"e",
">",
"set",
"view",
"<",
"e",
">",
"intersection",
"(",
"final",
"set",
"<",
"e",
">",
"set",
"1",
",",
"final",
"set",
"<",
"?",
">",
"set",
"2",
")",
"{",
"check",
"not",
"null",
"(",
"set",
"1",
",",
"\"",
"set",
"1",
"\"",
")",
";",
"check",
"not",
"null",
"(",
"set",
"2",
",",
"\"",
"set",
"2",
"\"",
")",
";",
"return",
"new",
"set",
"view",
"<",
"e",
">",
"(",
")",
"{",
"@",
"override",
"public",
"unmodifiable",
"iterator",
"<",
"e",
">",
"iterator",
"(",
")",
"{",
"return",
"new",
"abstract",
"iterator",
"<",
"e",
">",
"(",
")",
"{",
"final",
"iterator",
"<",
"e",
">",
"itr",
"=",
"set",
"1",
"iterator",
"(",
")",
";",
"@",
"override",
"protected",
"e",
"compute",
"next",
"(",
")",
"{",
"while",
"(",
"itr",
"has",
"next",
"(",
")",
")",
"{",
"e",
"e",
"=",
"itr",
"next",
"(",
")",
";",
"if",
"(",
"set",
"2",
"contains",
"(",
"e",
")",
")",
"{",
"return",
"e",
";",
"}",
"}",
"return",
"end",
"of",
"data",
"(",
")",
";",
"}",
"}",
";",
"}",
"@",
"override",
"public",
"int",
"size",
"(",
")",
"{",
"int",
"size",
"=",
"0",
";",
"for",
"(",
"e",
"e",
":",
"set",
"1",
")",
"{",
"if",
"(",
"set",
"2",
"contains",
"(",
"e",
")",
")",
"{",
"size",
"+",
"+",
";",
"}",
"}",
"return",
"size",
";",
"}",
"@",
"override",
"public",
"boolean",
"is",
"empty",
"(",
")",
"{",
"return",
"collections",
"disjoint",
"(",
"set",
"2",
",",
"set",
"1",
")",
";",
"}",
"@",
"override",
"public",
"boolean",
"contains",
"(",
"object",
"object",
")",
"{",
"return",
"set",
"1",
"contains",
"(",
"object",
")",
"&",
"&",
"set",
"2",
"contains",
"(",
"object",
")",
";",
"}",
"@",
"override",
"public",
"boolean",
"contains",
"all",
"(",
"collection",
"<",
"?",
">",
"collection",
")",
"{",
"return",
"set",
"1",
"contains",
"all",
"(",
"collection",
")",
"&",
"&",
"set",
"2",
"contains",
"all",
"(",
"collection",
")",
";",
"}",
"}",
";",
"}"
] |
[
"test",
"that",
"deep",
"stubbing",
"work",
"with",
"argument",
"patterns"
] |
[
"public",
"void",
"with",
"complex",
"pattern",
"arguments",
"(",
")",
"throws",
"exception",
"{",
"output",
"stream",
"out",
"1",
"=",
"new",
"byte",
"array",
"output",
"stream",
"(",
")",
";",
"output",
"stream",
"out",
"2",
"=",
"new",
"byte",
"array",
"output",
"stream",
"(",
")",
";",
"socket",
"factory",
"sf",
"=",
"mock",
"(",
"socket",
"factory",
"class",
",",
"returns",
"deep",
"stubs",
")",
";",
"when",
"(",
"sf",
"create",
"socket",
"(",
"any",
"string",
"(",
")",
",",
"eq",
"(",
"80",
")",
")",
"get",
"output",
"stream",
"(",
")",
")",
"then",
"return",
"(",
"out",
"1",
")",
";",
"when",
"(",
"sf",
"create",
"socket",
"(",
"any",
"string",
"(",
")",
",",
"eq",
"(",
"8080",
")",
")",
"get",
"output",
"stream",
"(",
")",
")",
"then",
"return",
"(",
"out",
"2",
")",
";",
"assert",
"same",
"(",
"out",
"2",
",",
"sf",
"create",
"socket",
"(",
"\"",
"stackoverflow",
"com",
"\"",
",",
"8080",
")",
"get",
"output",
"stream",
"(",
")",
")",
";",
"assert",
"same",
"(",
"out",
"1",
",",
"sf",
"create",
"socket",
"(",
"\"",
"google",
"com",
"\"",
",",
"80",
")",
"get",
"output",
"stream",
"(",
")",
")",
";",
"assert",
"same",
"(",
"out",
"2",
",",
"sf",
"create",
"socket",
"(",
"\"",
"google",
"com",
"\"",
",",
"8080",
")",
"get",
"output",
"stream",
"(",
")",
")",
";",
"assert",
"same",
"(",
"out",
"1",
",",
"sf",
"create",
"socket",
"(",
"\"",
"stackoverflow",
"com",
"\"",
",",
"80",
")",
"get",
"output",
"stream",
"(",
")",
")",
";",
"}"
] |
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"this",
"model",
"produces",
"the",
"same",
"image",
"using",
"the",
"same",
"mechanism",
"(",
"server",
",",
"authentication",
",",
"source",
"etc",
")",
"as",
"the",
"given",
"model",
"models",
"must",
"also",
"override",
"{",
"@",
"link",
"object",
"#",
"equals",
"(",
"object",
"other",
")",
"}",
"and",
"{",
"@",
"link",
"object",
"#",
"hash",
"code",
"(",
")",
"}",
"to",
"ensure",
"that",
"caching",
"functions",
"correctly",
"if",
"this",
"object",
"returns",
"{",
"@",
"code",
"true",
"}",
"from",
"this",
"method",
"for",
"a",
"given",
"model",
",",
"it",
"must",
"also",
"be",
"equal",
"to",
"and",
"have",
"the",
"same",
"hash",
"code",
"as",
"the",
"given",
"model",
"however",
",",
"this",
"model",
"may",
"be",
"equal",
"to",
"and",
"have",
"the",
"same",
"hash",
"code",
"as",
"a",
"given",
"model",
"but",
"still",
"return",
"{",
"@",
"code",
"false",
"}",
"from",
"this",
"method",
"this",
"method",
"optionally",
"allows",
"you",
"to",
"differentiate",
"between",
"models",
"that",
"load",
"the",
"same",
"image",
"via",
"multiple",
"different",
"means",
"for",
"example",
"one",
"model",
"might",
"load",
"the",
"image",
"from",
"server",
"a",
"and",
"another",
"model",
"might",
"load",
"the",
"same",
"image",
"from",
"server",
"b",
"the",
"models",
"must",
"be",
"equal",
"to",
"each",
"other",
"with",
"the",
"same",
"hash",
"code",
"because",
"they",
"load",
"the",
"same",
"image",
"however",
"two",
"requests",
"made",
"with",
"the",
"different",
"models",
"are",
"not",
"exactly",
"the",
"same",
"because",
"the",
"way",
"the",
"image",
"is",
"loaded",
"will",
"differ"
] |
[
"boolean",
"is",
"equivalent",
"to",
"(",
"@",
"nullable",
"object",
"other",
")",
";"
] |
[
"opens",
"the",
"given",
"file",
"in",
"an",
"editor"
] |
[
"private",
"void",
"open",
"in",
"editor",
"(",
"string",
"path",
")",
"{",
"file",
"file",
"to",
"open",
"=",
"new",
"file",
"(",
"path",
")",
";",
"if",
"(",
"file",
"to",
"open",
"exists",
"(",
")",
"&",
"&",
"file",
"to",
"open",
"is",
"file",
"(",
")",
")",
"{",
"display",
"get",
"default",
"(",
")",
"async",
"exec",
"(",
"new",
"open",
"file",
"runnable",
"(",
"path",
")",
")",
";",
"}",
"}"
] |
[
"read",
"and",
"verify",
"the",
"serde",
"version"
] |
[
"static",
"void",
"read",
"and",
"verify",
"coordinator",
"serde",
"version",
"(",
"data",
"input",
"stream",
"in",
")",
"throws",
"i",
"o",
"exception",
"{",
"int",
"version",
"=",
"in",
"read",
"int",
"(",
")",
";",
"if",
"(",
"version",
">",
"current",
"version",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"unsupported",
"source",
"coordinator",
"serde",
"version",
"\"",
"+",
"version",
")",
";",
"}",
"}"
] |
[
"substitute",
"special",
"variables",
"in",
"the",
"documentation",
"with",
"their",
"actual",
"values"
] |
[
"public",
"static",
"string",
"substitute",
"variables",
"(",
"string",
"documentation",
")",
"{",
"return",
"documentation",
"replace",
"(",
"\"",
"$",
"be",
"root",
"\"",
",",
"docgen",
"consts",
"be",
"docs",
"root",
")",
"replace",
"(",
"\"",
"$",
"doc",
"ext",
"\"",
",",
"docgen",
"consts",
"documentation",
"extension",
")",
";",
"}"
] |
[
"<",
"code",
">",
"optional",
"int",
"3",
"2",
"blah",
"=",
"1",
";",
"<",
"code",
">"
] |
[
"public",
"builder",
"clear",
"blah",
"(",
")",
"{",
"bit",
"field",
"0",
"=",
"(",
"bit",
"field",
"0",
"&",
"~",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"1",
")",
";",
"blah",
"=",
"0",
";",
"on",
"changed",
"(",
")",
";",
"return",
"this",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"namespace",
"wrapped",
"array",
"'"
] |
[
"public",
"void",
"namespace",
"wrapped",
"array",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"namespace",
"wrapped",
"array",
"}"
] |
[
"returns",
"true",
"if",
"local",
"passwords",
"are",
"in",
"use",
"and",
"can",
"be",
"changed",
"by",
"the",
"user"
] |
[
"public",
"boolean",
"can",
"set",
"password",
"(",
"string",
"username",
")",
"{",
"user",
"entry",
"user",
"entry",
"=",
"user",
"list",
"get",
"(",
"username",
")",
";",
"return",
"(",
"enable",
"local",
"passwords",
"&",
"&",
"user",
"entry",
"!",
"=",
"null",
"&",
"&",
"user",
"entry",
"password",
"hash",
"!",
"=",
"null",
")",
";",
"}"
] |
[
"appends",
"the",
"string",
"representation",
"of",
"the",
"specified",
"{",
"@",
"code",
"long",
"}",
"value",
"the",
"{",
"@",
"code",
"long",
"}",
"value",
"is",
"converted",
"to",
"a",
"string",
"without",
"memory",
"allocation"
] |
[
"public",
"string",
"builder",
"append",
"(",
"long",
"value",
")",
"{",
"return",
"append",
"(",
"value",
",",
"0",
")",
";",
"}"
] |
[
"returns",
"the",
"pointer",
"to",
"the",
"{",
"@",
"code",
"ssl",
"}",
"object",
"for",
"this",
"{",
"@",
"link",
"reference",
"counted",
"open",
"ssl",
"engine",
"}",
"be",
"aware",
"that",
"it",
"is",
"freed",
"as",
"soon",
"as",
"the",
"{",
"@",
"link",
"#",
"release",
"(",
")",
"}",
"or",
"{",
"@",
"link",
"#",
"shutdown",
"(",
")",
"}",
"methods",
"are",
"called",
"at",
"this",
"point",
"{",
"@",
"code",
"0",
"}",
"will",
"be",
"returned"
] |
[
"public",
"final",
"synchronized",
"long",
"ssl",
"pointer",
"(",
")",
"{",
"return",
"ssl",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"quantity",
"'"
] |
[
"public",
"void",
"quantity",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"quantity",
"}"
] |
[
"use",
"this",
"to",
"initialize",
"an",
"encrypted",
"s",
"q",
"l",
"cipher",
"database"
] |
[
"public",
"database",
"get",
"encrypted",
"readable",
"db",
"(",
"string",
"password",
")",
"{",
"encrypted",
"helper",
"encrypted",
"helper",
"=",
"check",
"encrypted",
"helper",
"(",
")",
";",
"return",
"encrypted",
"helper",
"get",
"encrypted",
"readable",
"db",
"(",
"password",
")",
";",
"}"
] |
[
"copies",
"the",
"content",
"of",
"the",
"source",
"resource",
"type",
"info",
"object",
"to",
"the",
"destination",
"object",
",",
"overwriting",
"all",
"properties",
"of",
"the",
"destination",
"object"
] |
[
"public",
"static",
"void",
"copy",
"(",
"resource",
"type",
"info",
"src",
",",
"resource",
"type",
"info",
"dst",
")",
"{",
"dst",
"set",
"name",
"(",
"src",
"get",
"name",
"(",
")",
")",
";",
"dst",
"set",
"resource",
"type",
"(",
"src",
"get",
"resource",
"type",
"(",
")",
")",
";",
"dst",
"set",
"default",
"unit",
"(",
"src",
"get",
"default",
"unit",
"(",
")",
")",
";",
"}"
] |
[
"request",
"an",
"incremental",
"update",
"for",
"the",
"specified",
"collection",
"the",
"source",
"may",
"choose",
"to",
"honor",
"this",
"request",
"or",
"ignore",
"and",
"and",
"provide",
"a",
"full",
"-",
"state",
"update",
"in",
"the",
"corresponding",
"`",
"resource",
"`",
"response",
"<",
"code",
">",
"bool",
"incremental",
"=",
"6",
";",
"<",
"code",
">"
] |
[
"public",
"boolean",
"get",
"incremental",
"(",
")",
"{",
"return",
"incremental",
";",
"}"
] |
[
"return",
"whether",
"there",
"are",
"any",
"registered",
"tool",
"listeners",
"for",
"the",
"tool",
"associated",
"with",
"class"
] |
[
"public",
"boolean",
"has",
"tool",
"listeners",
"(",
")",
"{",
"return",
"!",
"tool",
"listeners",
"is",
"empty",
"(",
")",
";",
"}"
] |
[
"computes",
"and",
"returns",
"an",
"md5",
"checksum",
"of",
"the",
"contents",
"of",
"all",
"files",
"in",
"the",
"input",
"maven",
"file",
"set"
] |
[
"private",
"string",
"compute",
"m",
"d",
"5",
"(",
")",
"throws",
"exception",
"{",
"list",
"<",
"file",
">",
"files",
"=",
"file",
"set",
"utils",
"convert",
"file",
"set",
"to",
"files",
"(",
"source",
")",
";",
"/",
"/",
"file",
"order",
"of",
"md5",
"calculation",
"is",
"significant",
"sorting",
"is",
"done",
"on",
"/",
"/",
"unix",
"-",
"format",
"names",
",",
"case",
"-",
"folded",
",",
"in",
"order",
"to",
"get",
"a",
"platform",
"-",
"independent",
"/",
"/",
"sort",
"and",
"calculate",
"the",
"same",
"md5",
"on",
"all",
"platforms",
"collections",
"sort",
"(",
"files",
",",
"new",
"m",
"d",
"5",
"comparator",
"(",
")",
")",
";",
"byte",
"[",
"]",
"md",
"5",
"=",
"compute",
"m",
"d",
"5",
"(",
"files",
")",
";",
"string",
"md",
"5str",
"=",
"byte",
"array",
"to",
"string",
"(",
"md",
"5",
")",
";",
"get",
"log",
"(",
")",
"info",
"(",
"\"",
"computed",
"md5",
":",
"\"",
"+",
"md",
"5str",
")",
";",
"return",
"md",
"5str",
";",
"}"
] |
[
"get",
"the",
"file",
"info",
"for",
"a",
"specific",
"file",
"or",
"directory"
] |
[
"public",
"hdfs",
"located",
"file",
"status",
"get",
"located",
"file",
"info",
"(",
"string",
"src",
",",
"boolean",
"need",
"block",
"token",
")",
"throws",
"i",
"o",
"exception",
"{",
"check",
"open",
"(",
")",
";",
"try",
"(",
"trace",
"scope",
"ignored",
"=",
"new",
"path",
"trace",
"scope",
"(",
"\"",
"get",
"located",
"file",
"info",
"\"",
",",
"src",
")",
")",
"{",
"return",
"namenode",
"get",
"located",
"file",
"info",
"(",
"src",
",",
"need",
"block",
"token",
")",
";",
"}",
"catch",
"(",
"remote",
"exception",
"re",
")",
"{",
"throw",
"re",
"unwrap",
"remote",
"exception",
"(",
"access",
"control",
"exception",
"class",
",",
"file",
"not",
"found",
"exception",
"class",
",",
"unresolved",
"path",
"exception",
"class",
")",
";",
"}",
"}"
] |
[
"add",
"the",
"given",
"data",
"to",
"the",
"destination",
"node"
] |
[
"void",
"add",
"(",
"program",
"node",
"dest",
"node",
",",
"program",
"node",
"[",
"]",
"drop",
"nodes",
",",
"int",
"drop",
"action",
",",
"int",
"relative",
"mouse",
"pos",
")",
"throws",
"not",
"found",
"exception",
",",
"circular",
"dependency",
"exception",
",",
"duplicate",
"group",
"exception",
"{",
"program",
"module",
"target",
"module",
"=",
"dest",
"node",
"get",
"module",
"(",
")",
";",
"program",
"fragment",
"target",
"frag",
"=",
"dest",
"node",
"get",
"fragment",
"(",
")",
";",
"if",
"(",
"target",
"module",
"=",
"=",
"null",
"&",
"&",
"target",
"frag",
"=",
"=",
"null",
")",
"{",
"tree",
"clear",
"drag",
"data",
"(",
")",
";",
"return",
";",
"/",
"/",
"ignore",
"the",
"drop",
"}",
"int",
"transaction",
"i",
"d",
"=",
"tree",
"start",
"transaction",
"(",
"\"",
"reorder",
"\"",
")",
";",
"if",
"(",
"transaction",
"i",
"d",
"<",
"0",
")",
"{",
"return",
";",
"}",
"try",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"drop",
"nodes",
"length",
";",
"i",
"+",
"+",
")",
"{",
"program",
"node",
"parent",
"node",
"=",
"(",
"program",
"node",
")",
"dest",
"node",
"get",
"parent",
"(",
")",
";",
"reorder",
"node",
"(",
"dest",
"node",
",",
"drop",
"action",
",",
"relative",
"mouse",
"pos",
",",
"parent",
"node",
",",
"drop",
"nodes",
"[",
"i",
"]",
")",
";",
"}",
"}",
"finally",
"{",
"tree",
"end",
"transaction",
"(",
"transaction",
"i",
"d",
",",
"true",
")",
";",
"}",
"}"
] |
[
"sets",
"the",
"{",
"@",
"link",
"resize",
"mode",
"}"
] |
[
"public",
"void",
"set",
"resize",
"mode",
"(",
"@",
"resize",
"mode",
"int",
"resize",
"mode",
")",
"{",
"assertions",
"check",
"state",
"not",
"null",
"(",
"content",
"frame",
")",
";",
"content",
"frame",
"set",
"resize",
"mode",
"(",
"resize",
"mode",
")",
";",
"}"
] |
[
"write",
"file",
"from",
"bytes",
"by",
"map"
] |
[
"public",
"static",
"boolean",
"write",
"file",
"from",
"bytes",
"by",
"map",
"(",
"final",
"string",
"file",
"path",
",",
"final",
"byte",
"[",
"]",
"bytes",
",",
"final",
"boolean",
"is",
"force",
")",
"{",
"return",
"write",
"file",
"from",
"bytes",
"by",
"map",
"(",
"file",
"path",
",",
"bytes",
",",
"false",
",",
"is",
"force",
")",
";",
"}"
] |
[
"returns",
"the",
"count",
"of",
"{",
"@",
"code",
"node",
"}",
"'",
"s",
"{",
"@",
"link",
"#",
"out",
"edges",
"(",
"object",
")",
"outgoing",
"edges",
"}",
"in",
"a",
"directed",
"network",
"in",
"an",
"undirected",
"network",
",",
"returns",
"the",
"{",
"@",
"link",
"#",
"degree",
"(",
"object",
")",
"}",
"if",
"the",
"count",
"is",
"greater",
"than",
"{",
"@",
"code",
"integer",
"max",
"value",
"}",
",",
"returns",
"{",
"@",
"code",
"integer",
"max",
"value",
"}"
] |
[
"int",
"out",
"degree",
"(",
"n",
"node",
")",
";"
] |
[
"decreases",
"the",
"reference",
"count",
"by",
"{",
"@",
"code",
"1",
"}",
"and",
"deallocates",
"this",
"object",
"if",
"the",
"reference",
"count",
"reaches",
"at",
"{",
"@",
"code",
"0",
"}"
] |
[
"boolean",
"release",
"(",
")",
";"
] |
[
"gets",
"the",
"number",
"of",
"repeatable",
"comments",
"at",
"the",
"\"",
"to",
"reference",
"\"",
"s"
] |
[
"public",
"int",
"get",
"referenced",
"repeatable",
"comments",
"count",
"(",
")",
"{",
"return",
"display",
"comment",
"arrays",
"[",
"ref",
"repeatables",
"]",
"length",
";",
"}"
] |
[
"parse",
"the",
"meta",
"elements",
"underneath",
"the",
"given",
"element",
",",
"if",
"any"
] |
[
"public",
"void",
"parse",
"meta",
"elements",
"(",
"element",
"ele",
",",
"bean",
"metadata",
"attribute",
"accessor",
"attribute",
"accessor",
")",
"{",
"node",
"list",
"nl",
"=",
"ele",
"get",
"child",
"nodes",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"nl",
"get",
"length",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"node",
"node",
"=",
"nl",
"item",
"(",
"i",
")",
";",
"if",
"(",
"is",
"candidate",
"element",
"(",
"node",
")",
"&",
"&",
"node",
"name",
"equals",
"(",
"node",
",",
"meta",
"element",
")",
")",
"{",
"element",
"meta",
"element",
"=",
"(",
"element",
")",
"node",
";",
"string",
"key",
"=",
"meta",
"element",
"get",
"attribute",
"(",
"key",
"attribute",
")",
";",
"string",
"value",
"=",
"meta",
"element",
"get",
"attribute",
"(",
"value",
"attribute",
")",
";",
"bean",
"metadata",
"attribute",
"attribute",
"=",
"new",
"bean",
"metadata",
"attribute",
"(",
"key",
",",
"value",
")",
";",
"attribute",
"set",
"source",
"(",
"extract",
"source",
"(",
"meta",
"element",
")",
")",
";",
"attribute",
"accessor",
"add",
"metadata",
"attribute",
"(",
"attribute",
")",
";",
"}",
"}",
"}"
] |
[
"this",
"method",
"sets",
"up",
"the",
"instance",
"variables",
"of",
"this",
"test",
"class",
"it",
"is",
"executed",
"before",
"the",
"execution",
"of",
"every",
"test"
] |
[
"public",
"void",
"setup",
"(",
")",
"{",
"ejb",
"service",
"=",
"spy",
"(",
"new",
"ejb",
"service",
"(",
")",
")",
";",
"jms",
"service",
"=",
"spy",
"(",
"new",
"jms",
"service",
"(",
")",
")",
";",
"business",
"lookup",
"=",
"spy",
"(",
"new",
"business",
"lookup",
"(",
")",
")",
";",
"business",
"lookup",
"set",
"ejb",
"service",
"(",
"ejb",
"service",
")",
";",
"business",
"lookup",
"set",
"jms",
"service",
"(",
"jms",
"service",
")",
";",
"business",
"delegate",
"=",
"spy",
"(",
"new",
"business",
"delegate",
"(",
")",
")",
";",
"business",
"delegate",
"set",
"lookup",
"service",
"(",
"business",
"lookup",
")",
";",
"}"
] |
[
"returns",
"estimate",
"of",
"capacity",
"lost",
"this",
"is",
"said",
"to",
"be",
"an",
"estimate",
",",
"because",
"in",
"some",
"cases",
"it",
"'",
"s",
"impossible",
"to",
"know",
"the",
"capacity",
"of",
"the",
"volume",
",",
"such",
"as",
"if",
"we",
"never",
"had",
"a",
"chance",
"to",
"query",
"its",
"capacity",
"before",
"the",
"failure",
"occurred"
] |
[
"public",
"long",
"get",
"estimated",
"capacity",
"lost",
"(",
")",
"{",
"return",
"this",
"estimated",
"capacity",
"lost",
";",
"}"
] |
[
"get",
"a",
"copy",
"of",
"a",
"http",
"request",
"this",
"is",
"for",
"thread",
"safety"
] |
[
"private",
"http",
"servlet",
"request",
"wrapper",
"clone",
"(",
"final",
"http",
"servlet",
"request",
"hsr",
")",
"{",
"if",
"(",
"hsr",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"@",
"suppress",
"warnings",
"(",
"\"",
"unchecked",
"\"",
")",
"final",
"map",
"<",
"string",
",",
"string",
"[",
"]",
">",
"parameter",
"map",
"=",
"(",
"map",
"<",
"string",
",",
"string",
"[",
"]",
">",
")",
"hsr",
"get",
"parameter",
"map",
"(",
")",
";",
"final",
"string",
"path",
"info",
"=",
"hsr",
"get",
"path",
"info",
"(",
")",
";",
"final",
"string",
"user",
"=",
"hsr",
"get",
"remote",
"user",
"(",
")",
";",
"final",
"principal",
"principal",
"=",
"hsr",
"get",
"user",
"principal",
"(",
")",
";",
"final",
"string",
"media",
"type",
"=",
"router",
"web",
"service",
"util",
"get",
"media",
"type",
"from",
"http",
"servlet",
"request",
"(",
"hsr",
",",
"apps",
"info",
"class",
")",
";",
"return",
"new",
"http",
"servlet",
"request",
"wrapper",
"(",
"hsr",
")",
"{",
"public",
"map",
"<",
"string",
",",
"string",
"[",
"]",
">",
"get",
"parameter",
"map",
"(",
")",
"{",
"return",
"parameter",
"map",
";",
"}",
"public",
"string",
"get",
"path",
"info",
"(",
")",
"{",
"return",
"path",
"info",
";",
"}",
"public",
"string",
"get",
"remote",
"user",
"(",
")",
"{",
"return",
"user",
";",
"}",
"public",
"principal",
"get",
"user",
"principal",
"(",
")",
"{",
"return",
"principal",
";",
"}",
"public",
"string",
"get",
"header",
"(",
"string",
"value",
")",
"{",
"/",
"/",
"we",
"override",
"only",
"accept",
"if",
"(",
"value",
"equals",
"(",
"http",
"headers",
"accept",
")",
")",
"{",
"return",
"media",
"type",
";",
"}",
"return",
"null",
";",
"}",
"}",
";",
"}"
] |
[
"execute",
"a",
"put",
"request",
"with",
"the",
"given",
"connector",
"configuration",
"on",
"the",
"given",
"url",
"endpoint"
] |
[
"protected",
"string",
"put",
"connector",
"config",
"(",
"string",
"url",
",",
"map",
"<",
"string",
",",
"string",
">",
"conn",
"config",
")",
"{",
"object",
"mapper",
"mapper",
"=",
"new",
"object",
"mapper",
"(",
")",
";",
"string",
"content",
";",
"try",
"{",
"content",
"=",
"mapper",
"write",
"value",
"as",
"string",
"(",
"conn",
"config",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"throw",
"new",
"connect",
"exception",
"(",
"\"",
"could",
"not",
"serialize",
"connector",
"configuration",
"and",
"execute",
"put",
"request",
"\"",
")",
";",
"}",
"response",
"response",
"=",
"request",
"put",
"(",
"url",
",",
"content",
")",
";",
"if",
"(",
"response",
"get",
"status",
"(",
")",
"<",
"response",
"status",
"bad",
"request",
"get",
"status",
"code",
"(",
")",
")",
"{",
"return",
"response",
"to",
"string",
"(",
"response",
")",
";",
"}",
"throw",
"new",
"connect",
"rest",
"exception",
"(",
"response",
"get",
"status",
"(",
")",
",",
"\"",
"could",
"not",
"execute",
"put",
"request",
"error",
"response",
":",
"\"",
"+",
"response",
"to",
"string",
"(",
"response",
")",
")",
";",
"}"
] |
[
"add",
"a",
"running",
"job",
"'",
"s",
"status",
"to",
"the",
"polling",
"queue"
] |
[
"public",
"void",
"add",
"(",
"job",
"stats",
"job",
")",
"throws",
"interrupted",
"exception",
"{",
"running",
"jobs",
"put",
"(",
"job",
")",
";",
"}"
] |
[
"get",
"namespace",
"integer"
] |
[
"public",
"integer",
"get",
"namespace",
"integer",
"(",
")",
"{",
"return",
"namespace",
"integer",
";",
"}"
] |
[
"asynchronously",
"executes",
"a",
"request",
"using",
"the",
"multi",
"search",
"template",
"api",
"see",
"<",
"a",
"href",
"=",
"\"",
"https",
":",
"www",
"elastic",
"coguideenelasticsearchreferencecurrentmulti",
"-",
"search",
"-",
"template",
"html",
"\"",
">",
"multi",
"search",
"template",
"api",
"on",
"elastic",
"co"
] |
[
"public",
"final",
"cancellable",
"msearch",
"template",
"async",
"(",
"multi",
"search",
"template",
"request",
"multi",
"search",
"template",
"request",
",",
"request",
"options",
"options",
",",
"action",
"listener",
"<",
"multi",
"search",
"template",
"response",
">",
"listener",
")",
"{",
"return",
"perform",
"request",
"async",
"and",
"parse",
"entity",
"(",
"multi",
"search",
"template",
"request",
",",
"request",
"converters",
":",
":",
"multi",
"search",
"template",
",",
"options",
",",
"multi",
"search",
"template",
"response",
":",
":",
"from",
"x",
"context",
",",
"listener",
",",
"empty",
"set",
"(",
")",
")",
";",
"}"
] |
[
"handles",
"a",
"lifeline",
"message",
"sent",
"by",
"a",
"data",
"node",
"this",
"method",
"updates",
"contact",
"information",
"and",
"statistics",
"for",
"the",
"data",
"node",
",",
"so",
"that",
"it",
"doesn",
"'",
"t",
"time",
"out",
"unlike",
"a",
"heartbeat",
",",
"this",
"method",
"does",
"not",
"dispatch",
"any",
"commands",
"back",
"to",
"the",
"data",
"node",
"for",
"local",
"execution",
"this",
"method",
"also",
"cannot",
"request",
"a",
"lease",
"for",
"sending",
"a",
"full",
"block",
"report",
"lifeline",
"messages",
"are",
"used",
"only",
"as",
"a",
"fallback",
"in",
"case",
"something",
"prevents",
"successful",
"delivery",
"of",
"heartbeat",
"messages",
"therefore",
",",
"the",
"implementation",
"of",
"this",
"method",
"must",
"remain",
"lightweight",
"compared",
"to",
"heartbeat",
"handling",
"it",
"should",
"avoid",
"lock",
"contention",
"and",
"expensive",
"computation"
] |
[
"void",
"handle",
"lifeline",
"(",
"datanode",
"registration",
"node",
"reg",
",",
"storage",
"report",
"[",
"]",
"reports",
",",
"long",
"cache",
"capacity",
",",
"long",
"cache",
"used",
",",
"int",
"xceiver",
"count",
",",
"int",
"xmits",
"in",
"progress",
",",
"int",
"failed",
"volumes",
",",
"volume",
"failure",
"summary",
"volume",
"failure",
"summary",
")",
"throws",
"i",
"o",
"exception",
"{",
"int",
"max",
"transfer",
"=",
"block",
"manager",
"get",
"max",
"replication",
"streams",
"(",
")",
"-",
"xmits",
"in",
"progress",
";",
"block",
"manager",
"get",
"datanode",
"manager",
"(",
")",
"handle",
"lifeline",
"(",
"node",
"reg",
",",
"reports",
",",
"get",
"block",
"pool",
"id",
"(",
")",
",",
"cache",
"capacity",
",",
"cache",
"used",
",",
"xceiver",
"count",
",",
"max",
"transfer",
",",
"failed",
"volumes",
",",
"volume",
"failure",
"summary",
")",
";",
"}"
] |
[
"returns",
"{",
"@",
"link",
"integer",
"redis",
"message",
"}",
"for",
"given",
"{",
"@",
"code",
"content",
"}",
"returns",
"{",
"@",
"code",
"null",
"}",
"it",
"does",
"not",
"exist"
] |
[
"integer",
"redis",
"message",
"get",
"integer",
"(",
"byte",
"buf",
"content",
")",
";"
] |
[
"get",
"namespace",
"array"
] |
[
"public",
"list",
"<",
"integer",
">",
"get",
"namespace",
"array",
"(",
")",
"{",
"return",
"namespace",
"array",
";",
"}"
] |
[
"test",
"that",
"default",
"blocksize",
"values",
"can",
"be",
"retrieved",
"on",
"the",
"client",
"side"
] |
[
"public",
"void",
"test",
"get",
"default",
"block",
"size",
"(",
")",
"throws",
"i",
"o",
"exception",
",",
"u",
"r",
"i",
"syntax",
"exception",
"{",
"/",
"/",
"create",
"file",
"does",
"not",
"use",
"default",
"block",
"size",
"to",
"create",
"the",
"file",
",",
"/",
"/",
"but",
"we",
"are",
"only",
"looking",
"at",
"the",
"default",
"block",
"size",
",",
"so",
"this",
"/",
"/",
"test",
"should",
"still",
"pass",
"try",
"{",
"vfs",
"get",
"default",
"block",
"size",
"(",
"not",
"in",
"mountpoint",
"path",
")",
";",
"fail",
"(",
"\"",
"get",
"server",
"defaults",
"on",
"view",
"fs",
"did",
"not",
"throw",
"excetion",
"!",
"\"",
")",
";",
"}",
"catch",
"(",
"not",
"in",
"mountpoint",
"exception",
"e",
")",
"{",
"assert",
"equals",
"(",
"vfs",
"get",
"default",
"block",
"size",
"(",
"test",
"file",
"path",
")",
",",
"dfs",
"block",
"size",
"default",
")",
";",
"}",
"}"
] |
[
"returns",
"a",
"padding",
"result",
"with",
"the",
"given",
"right",
"row"
] |
[
"public",
"final",
"row",
"data",
"pad",
"right",
"(",
"row",
"data",
"right",
"row",
")",
"{",
"return",
"joined",
"row",
"replace",
"(",
"left",
"null",
"padding",
"row",
",",
"right",
"row",
")",
";",
"}"
] |
[
"removes",
"the",
"attribute",
"from",
"the",
"material",
",",
"i",
"e",
":",
"material",
"remove",
"(",
"blending",
"attribute",
"id",
")",
";",
"can",
"also",
"be",
"used",
"to",
"remove",
"multiple",
"attributes",
"also",
",",
"i",
"e",
"remove",
"(",
"attribute",
"a",
"id",
"|",
"attribute",
"b",
"id",
")",
";"
] |
[
"public",
"final",
"void",
"remove",
"(",
"final",
"long",
"mask",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"attributes",
"size",
"-",
"1",
";",
"i",
">",
"=",
"0",
";",
"i",
"-",
"-",
")",
"{",
"final",
"long",
"type",
"=",
"attributes",
"get",
"(",
"i",
")",
"type",
";",
"if",
"(",
"(",
"mask",
"&",
"type",
")",
"=",
"=",
"type",
")",
"{",
"attributes",
"remove",
"index",
"(",
"i",
")",
";",
"disable",
"(",
"type",
")",
";",
"sorted",
"=",
"false",
";",
"}",
"}",
"sort",
"(",
")",
";",
"/",
"/",
"fixme",
":",
"see",
"#",
"4186",
"}"
] |
[
"framework",
"group",
":",
":",
"=",
"#",
"counter",
"(",
"key",
"value",
")"
] |
[
"public",
"void",
"write",
"(",
"data",
"output",
"out",
")",
"throws",
"i",
"o",
"exception",
"{",
"writable",
"utils",
"write",
"v",
"int",
"(",
"out",
",",
"size",
"(",
")",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"counters",
"length",
";",
"+",
"+",
"i",
")",
"{",
"counter",
"counter",
"=",
"(",
"c",
")",
"counters",
"[",
"i",
"]",
";",
"if",
"(",
"counter",
"!",
"=",
"null",
")",
"{",
"writable",
"utils",
"write",
"v",
"int",
"(",
"out",
",",
"i",
")",
";",
"writable",
"utils",
"write",
"v",
"long",
"(",
"out",
",",
"counter",
"get",
"value",
"(",
")",
")",
";",
"}",
"}",
"}"
] |
[
"removes",
"a",
"specified",
"key",
"from",
"this",
"counting",
"bloom",
"filter",
"<",
"b",
">",
"invariant",
"<",
"b",
">",
":",
"nothing",
"happens",
"if",
"the",
"specified",
"key",
"does",
"not",
"belong",
"to",
"this",
"counter",
"bloom",
"filter"
] |
[
"public",
"void",
"delete",
"(",
"key",
"key",
")",
"{",
"if",
"(",
"key",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"null",
"pointer",
"exception",
"(",
"\"",
"key",
"may",
"not",
"be",
"null",
"\"",
")",
";",
"}",
"if",
"(",
"!",
"membership",
"test",
"(",
"key",
")",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"key",
"is",
"not",
"a",
"member",
"\"",
")",
";",
"}",
"int",
"[",
"]",
"h",
"=",
"hash",
"hash",
"(",
"key",
")",
";",
"hash",
"clear",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"nb",
"hash",
";",
"i",
"+",
"+",
")",
"{",
"/",
"/",
"find",
"the",
"bucket",
"int",
"word",
"num",
"=",
"h",
"[",
"i",
"]",
">",
">",
"4",
";",
"/",
"/",
"div",
"16",
"int",
"bucket",
"shift",
"=",
"(",
"h",
"[",
"i",
"]",
"&",
"0x",
"0f",
")",
"<",
"<",
"2",
";",
"/",
"/",
"(",
"mod",
"16",
")",
"*",
"4",
"long",
"bucket",
"mask",
"=",
"15l",
"<",
"<",
"bucket",
"shift",
";",
"long",
"bucket",
"value",
"=",
"(",
"buckets",
"[",
"word",
"num",
"]",
"&",
"bucket",
"mask",
")",
">",
">",
">",
"bucket",
"shift",
";",
"/",
"/",
"only",
"decrement",
"if",
"the",
"count",
"in",
"the",
"bucket",
"is",
"between",
"0",
"and",
"bucket",
"max",
"value",
"if",
"(",
"bucket",
"value",
">",
"=",
"1",
"&",
"&",
"bucket",
"value",
"<",
"bucket",
"max",
"value",
")",
"{",
"/",
"/",
"decrement",
"by",
"1",
"buckets",
"[",
"word",
"num",
"]",
"=",
"(",
"buckets",
"[",
"word",
"num",
"]",
"&",
"~",
"bucket",
"mask",
")",
"|",
"(",
"(",
"bucket",
"value",
"-",
"1",
")",
"<",
"<",
"bucket",
"shift",
")",
";",
"}",
"}",
"}"
] |
[
"constructor",
"initializes",
"to",
"given",
"value"
] |
[
"public",
"void",
"test",
"constructor",
"(",
")",
"{",
"for",
"(",
"double",
"x",
":",
"values",
")",
"{",
"atomic",
"double",
"a",
"=",
"new",
"atomic",
"double",
"(",
"x",
")",
";",
"assert",
"bit",
"equals",
"(",
"x",
",",
"a",
"get",
"(",
")",
")",
";",
"}",
"}"
] |
[
"checks",
"and",
"normalizes",
"the",
"given",
"uri",
"this",
"method",
"first",
"checks",
"the",
"validity",
"of",
"the",
"uri",
"(",
"scheme",
"and",
"path",
"are",
"not",
"null",
")",
"and",
"then",
"normalizes",
"the",
"uri",
"to",
"a",
"path"
] |
[
"public",
"static",
"path",
"validate",
"and",
"normalize",
"uri",
"(",
"uri",
"archive",
"dir",
"uri",
")",
"{",
"final",
"string",
"scheme",
"=",
"archive",
"dir",
"uri",
"get",
"scheme",
"(",
")",
";",
"final",
"string",
"path",
"=",
"archive",
"dir",
"uri",
"get",
"path",
"(",
")",
";",
"/",
"/",
"some",
"validity",
"checks",
"if",
"(",
"scheme",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"the",
"scheme",
"(",
"hdfs",
":",
"/",
"/",
",",
"file",
":",
"/",
"/",
",",
"etc",
")",
"is",
"null",
"\"",
"+",
"\"",
"please",
"specify",
"the",
"file",
"system",
"scheme",
"explicitly",
"in",
"the",
"uri",
"\"",
")",
";",
"}",
"if",
"(",
"path",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"the",
"path",
"to",
"store",
"the",
"job",
"archive",
"data",
"in",
"is",
"null",
"\"",
"+",
"\"",
"please",
"specify",
"a",
"directory",
"path",
"for",
"the",
"archiving",
"the",
"job",
"data",
"\"",
")",
";",
"}",
"return",
"new",
"path",
"(",
"archive",
"dir",
"uri",
")",
";",
"}"
] |
[
"turn",
"speculative",
"execution",
"on",
"or",
"off",
"for",
"this",
"job",
"for",
"reduce",
"tasks"
] |
[
"public",
"void",
"set",
"reduce",
"speculative",
"execution",
"(",
"boolean",
"speculative",
"execution",
")",
"{",
"ensure",
"state",
"(",
"job",
"state",
"define",
")",
";",
"conf",
"set",
"reduce",
"speculative",
"execution",
"(",
"speculative",
"execution",
")",
";",
"}"
] |
[
"hpack",
"has",
"a",
"max",
"header",
"table",
"size",
",",
"which",
"can",
"be",
"smaller",
"than",
"the",
"max",
"header",
"message",
"ensure",
"the",
"larger",
"header",
"content",
"is",
"not",
"lost"
] |
[
"@",
"test",
"public",
"void",
"too",
"large",
"to",
"h",
"pack",
"is",
"still",
"emitted",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"bytes",
"in",
"write",
"byte",
"(",
"0x",
"2",
"1",
")",
";",
"/",
"/",
"dynamic",
"table",
"size",
"update",
"(",
"size",
"=",
"1",
")",
"bytes",
"in",
"write",
"byte",
"(",
"0x",
"0",
"0",
")",
";",
"/",
"/",
"literal",
"indexed",
"bytes",
"in",
"write",
"byte",
"(",
"0x",
"0a",
")",
";",
"/",
"/",
"literal",
"name",
"(",
"len",
"=",
"10",
")",
"bytes",
"in",
"write",
"utf",
"8",
"(",
"\"",
"custom",
"-",
"key",
"\"",
")",
";",
"bytes",
"in",
"write",
"byte",
"(",
"0x",
"0d",
")",
";",
"/",
"/",
"literal",
"value",
"(",
"len",
"=",
"13",
")",
"bytes",
"in",
"write",
"utf",
"8",
"(",
"\"",
"custom",
"-",
"header",
"\"",
")",
";",
"hpack",
"reader",
"header",
"table",
"size",
"setting",
"(",
"1",
")",
";",
"hpack",
"reader",
"read",
"headers",
"(",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"hpack",
"reader",
"dynamic",
"table",
"header",
"count",
")",
";",
"assert",
"equals",
"(",
"header",
"entries",
"(",
"\"",
"custom",
"-",
"key",
"\"",
",",
"\"",
"custom",
"-",
"header",
"\"",
")",
",",
"hpack",
"reader",
"get",
"and",
"reset",
"header",
"list",
"(",
")",
")",
";",
"}"
] |
[
"creates",
"a",
"new",
"code",
"completion",
"from",
"the",
"given",
"python",
"objects"
] |
[
"public",
"static",
"code",
"completion",
"new",
"code",
"completion",
"(",
"string",
"description",
",",
"string",
"insertion",
",",
"py",
"object",
"py",
"obj",
")",
"{",
"j",
"component",
"comp",
"=",
"null",
";",
"if",
"(",
"py",
"obj",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"include",
"types",
")",
"{",
"/",
"*",
"append",
"the",
"class",
"name",
"to",
"the",
"end",
"of",
"the",
"description",
"*",
"/",
"string",
"class",
"name",
"=",
"get",
"simple",
"name",
"(",
"py",
"obj",
"get",
"class",
"(",
")",
")",
";",
"if",
"(",
"py",
"obj",
"instanceof",
"py",
"instance",
")",
"{",
"/",
"*",
"get",
"the",
"real",
"class",
"*",
"/",
"class",
"name",
"=",
"get",
"simple",
"name",
"(",
"(",
"(",
"py",
"instance",
")",
"py",
"obj",
")",
"instclass",
"name",
")",
";",
"}",
"else",
"if",
"(",
"class",
"name",
"starts",
"with",
"(",
"\"",
"py",
"\"",
")",
")",
"{",
"/",
"*",
"strip",
"off",
"the",
"\"",
"py",
"\"",
"*",
"/",
"class",
"name",
"=",
"class",
"name",
"substring",
"(",
"\"",
"py",
"\"",
"length",
"(",
")",
")",
";",
"}",
"description",
"=",
"description",
"+",
"\"",
"(",
"\"",
"+",
"class",
"name",
"+",
"\"",
")",
"\"",
";",
"}",
"comp",
"=",
"new",
"g",
"d",
"label",
"(",
"description",
")",
";",
"iterator",
"<",
"class",
"<",
"?",
">",
">",
"iter",
"=",
"classes",
"iterator",
"(",
")",
";",
"while",
"(",
"iter",
"has",
"next",
"(",
")",
")",
"{",
"class",
"<",
"?",
">",
"test",
"class",
"=",
"iter",
"next",
"(",
")",
";",
"if",
"(",
"test",
"class",
"is",
"instance",
"(",
"py",
"obj",
")",
")",
"{",
"comp",
"set",
"foreground",
"(",
"class",
"to",
"color",
"map",
"get",
"(",
"test",
"class",
")",
")",
";",
"break",
";",
"}",
"}",
"}",
"return",
"new",
"code",
"completion",
"(",
"description",
",",
"insertion",
",",
"comp",
")",
";",
"}"
] |
[
"decodes",
"a",
"byte",
"array",
"from",
"base",
"6",
"4",
"format",
"and",
"ignores",
"line",
"separators",
",",
"tabs",
"and",
"blanks",
"cr",
",",
"lf",
",",
"tab",
"and",
"space",
"characters",
"are",
"ignored",
"in",
"the",
"input",
"data",
"this",
"method",
"is",
"compatible",
"with",
"<",
"code",
">",
"sun",
"misc",
"b",
"a",
"s",
"e",
"6",
"4",
"decoder",
"decode",
"buffer",
"(",
"string",
")",
"<",
"code",
">"
] |
[
"public",
"static",
"byte",
"[",
"]",
"decode",
"lines",
"(",
"string",
"s",
",",
"byte",
"[",
"]",
"inverse",
"char",
"map",
")",
"{",
"char",
"[",
"]",
"buf",
"=",
"new",
"char",
"[",
"s",
"length",
"(",
")",
"]",
";",
"int",
"p",
"=",
"0",
";",
"for",
"(",
"int",
"ip",
"=",
"0",
";",
"ip",
"<",
"s",
"length",
"(",
")",
";",
"ip",
"+",
"+",
")",
"{",
"char",
"c",
"=",
"s",
"char",
"at",
"(",
"ip",
")",
";",
"if",
"(",
"c",
"!",
"=",
"'",
"'",
"&",
"&",
"c",
"!",
"=",
"'",
"\\",
"r",
"'",
"&",
"&",
"c",
"!",
"=",
"'",
"\\",
"n",
"'",
"&",
"&",
"c",
"!",
"=",
"'",
"\\",
"t",
"'",
")",
"{",
"buf",
"[",
"p",
"+",
"+",
"]",
"=",
"c",
";",
"}",
"}",
"return",
"decode",
"(",
"buf",
",",
"0",
",",
"p",
",",
"inverse",
"char",
"map",
")",
";",
"}"
] |
[
"whether",
"this",
"instance",
"contains",
"0",
"conditions",
"or",
"not"
] |
[
"public",
"boolean",
"is",
"empty",
"(",
")",
"{",
"return",
"object",
"utils",
"is",
"empty",
"(",
"this",
"request",
"conditions",
")",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.