docstring_tokens
list | code_tokens
list |
|---|---|
[
"installs",
"the",
"long",
"click",
"listeners",
"that",
"will",
"dispatch",
"the",
"click",
"handler",
"defined",
"in",
"the",
"component",
"'",
"s",
"props",
"unconditionally",
"set",
"the",
"clickable",
"flag",
"on",
"the",
"view"
] | [
"private",
"static",
"void",
"set",
"long",
"click",
"handler",
"(",
"@",
"nullable",
"event",
"handler",
"<",
"long",
"click",
"event",
">",
"long",
"click",
"handler",
",",
"view",
"view",
")",
"{",
"if",
"(",
"long",
"click",
"handler",
"!",
"=",
"null",
")",
"{",
"component",
"long",
"click",
"listener",
"listener",
"=",
"get",
"component",
"long",
"click",
"listener",
"(",
"view",
")",
";",
"if",
"(",
"listener",
"=",
"=",
"null",
")",
"{",
"listener",
"=",
"new",
"component",
"long",
"click",
"listener",
"(",
")",
";",
"set",
"component",
"long",
"click",
"listener",
"(",
"view",
",",
"listener",
")",
";",
"}",
"listener",
"set",
"event",
"handler",
"(",
"long",
"click",
"handler",
")",
";",
"view",
"set",
"long",
"clickable",
"(",
"true",
")",
";",
"}",
"}"
] |
[
"global",
"lock",
"config",
"info"
] | [
"global",
"lock",
"config",
"get",
"global",
"lock",
"config",
"(",
")",
";"
] |
[
"this",
"version",
"of",
"{",
"@",
"link",
"#",
"load",
"ask",
"value",
"(",
"string",
"transformer",
",",
"string",
")",
"}",
"will",
"use",
"the",
"given",
"default",
",",
"if",
"not",
"null",
"and",
"not",
"empty",
",",
"instead",
"of",
"failing",
"when",
"a",
"value",
"is",
"not",
"provided",
"by",
"the",
"client",
"when",
"in",
"headless"
] | [
"private",
"<",
"t",
">",
"t",
"load",
"ask",
"value",
"(",
"t",
"default",
"value",
",",
"string",
"transformer",
"<",
"t",
">",
"transformer",
",",
"string",
"key",
")",
"{",
"boolean",
"is",
"headless",
"=",
"is",
"running",
"headless",
"(",
")",
";",
"if",
"(",
"is",
"headless",
"&",
"&",
"script",
"args",
"length",
">",
"0",
")",
"{",
"/",
"/",
"this",
"will",
"throw",
"illegal",
"argumenr",
"exception",
"if",
"the",
"args",
"cannot",
"be",
"parsed",
"return",
"transformer",
"apply",
"(",
"next",
"script",
"arg",
"(",
")",
")",
";",
"}",
"boolean",
"has",
"default",
"=",
"!",
"is",
"blank",
"(",
"default",
"value",
")",
";",
"string",
"property",
"key",
"=",
"key",
";",
"if",
"(",
"properties",
"file",
"params",
"=",
"=",
"null",
")",
"{",
"if",
"(",
"is",
"headless",
"&",
"&",
"!",
"has",
"default",
")",
"{",
"/",
"/",
"require",
"either",
"a",
"props",
"file",
"or",
"a",
"default",
"value",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"error",
"processing",
"variable",
"'",
"\"",
"+",
"property",
"key",
"+",
"\"",
"'",
"in",
"headless",
"mode",
"-",
"-",
"it",
"was",
"not",
"found",
"in",
"a",
"properties",
"file",
"\"",
")",
";",
"}",
"return",
"default",
"value",
";",
"/",
"/",
"may",
"be",
"null",
"}",
"string",
"stored",
"value",
"=",
"properties",
"file",
"params",
"get",
"value",
"(",
"property",
"key",
")",
";",
"if",
"(",
"stored",
"value",
"is",
"empty",
"(",
")",
")",
"{",
"if",
"(",
"is",
"headless",
"&",
"&",
"!",
"has",
"default",
")",
"{",
"/",
"/",
"require",
"either",
"a",
"props",
"file",
"or",
"a",
"default",
"value",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"error",
"processing",
"variable",
"'",
"\"",
"+",
"property",
"key",
"+",
"\"",
"'",
"in",
"headless",
"mode",
"-",
"-",
"it",
"was",
"not",
"found",
"in",
"a",
"properties",
"file",
"\"",
")",
";",
"}",
"return",
"default",
"value",
";",
"}",
"try",
"{",
"t",
"t",
"=",
"transformer",
"apply",
"(",
"stored",
"value",
")",
";",
"return",
"t",
";",
"}",
"catch",
"(",
"illegal",
"argument",
"exception",
"e",
")",
"{",
"/",
"/",
"handled",
"below",
"}",
"if",
"(",
"is",
"headless",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"error",
"processing",
"variable",
"'",
"\"",
"+",
"property",
"key",
"+",
"\"",
"'",
"in",
"headless",
"mode",
"-",
"-",
"its",
"value",
"'",
"\"",
"+",
"stored",
"value",
"+",
"\"",
"'",
"is",
"not",
"a",
"valid",
"value",
"\"",
")",
";",
"}",
"msg",
"warn",
"(",
"this",
",",
"\"",
"failed",
"to",
"parse",
"script",
"properties",
"value",
"'",
"\"",
"+",
"key",
"+",
"\"",
"'",
"from",
"file",
"\"",
"+",
"properties",
"file",
"params",
"get",
"filename",
"(",
")",
")",
";",
"return",
"null",
";",
"}"
] |
[
"lottie",
"has",
"a",
"default",
"network",
"fetching",
"stack",
"built",
"on",
"{",
"@",
"link",
"java",
"net",
"http",
"u",
"r",
"l",
"connection",
"}",
"however",
",",
"if",
"you",
"would",
"like",
"to",
"hook",
"into",
"your",
"own",
"network",
"stack",
"for",
"performance",
",",
"caching",
",",
"or",
"analytics",
",",
"you",
"may",
"replace",
"the",
"internal",
"stack",
"with",
"your",
"own"
] | [
"public",
"builder",
"set",
"network",
"fetcher",
"(",
"@",
"non",
"null",
"lottie",
"network",
"fetcher",
"fetcher",
")",
"{",
"this",
"network",
"fetcher",
"=",
"fetcher",
";",
"return",
"this",
";",
"}"
] |
[
"an",
"expectation",
"for",
"checking",
"that",
"an",
"element",
",",
"known",
"to",
"be",
"present",
"on",
"the",
"dom",
"of",
"a",
"page",
",",
"is",
"visible",
"visibility",
"means",
"that",
"the",
"element",
"is",
"not",
"only",
"displayed",
"but",
"also",
"has",
"a",
"height",
"and",
"width",
"that",
"is",
"greater",
"than",
"0"
] | [
"public",
"static",
"expected",
"condition",
"<",
"web",
"element",
">",
"visibility",
"of",
"(",
"final",
"web",
"element",
"element",
")",
"{",
"return",
"new",
"expected",
"condition",
"<",
"web",
"element",
">",
"(",
")",
"{",
"@",
"override",
"public",
"web",
"element",
"apply",
"(",
"web",
"driver",
"driver",
")",
"{",
"return",
"element",
"if",
"visible",
"(",
"element",
")",
";",
"}",
"@",
"override",
"public",
"string",
"to",
"string",
"(",
")",
"{",
"return",
"\"",
"visibility",
"of",
"\"",
"+",
"element",
";",
"}",
"}",
";",
"}"
] |
[
"sets",
"the",
"query",
"to",
"use",
"when",
"fetching",
"the",
"data",
"convenience",
"method",
"for",
"{",
"@",
"link",
"#",
"set",
"query",
"config",
"(",
"query",
"config",
")",
"}"
] | [
"public",
"builder",
"set",
"query",
"(",
"query",
"builder",
"query",
")",
"{",
"return",
"this",
"set",
"query",
"config",
"(",
"new",
"query",
"config",
"(",
"query",
")",
")",
";",
"}"
] |
[
"for",
"this",
"test",
",",
"the",
"body",
"for",
"this",
"request",
"much",
"reference",
"a",
"schema",
"named",
"&",
"#",
"x",
"6",
"0",
";",
"file",
"&",
"#",
"x",
"6",
"0",
";"
] | [
"public",
"void",
"test",
"body",
"with",
"file",
"schema",
"test",
"(",
")",
"{",
"file",
"schema",
"test",
"class",
"file",
"schema",
"test",
"class",
"=",
"null",
";",
"/",
"/",
"api",
"test",
"body",
"with",
"file",
"schema",
"(",
"file",
"schema",
"test",
"class",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
] |
[
"dispatches",
"{",
"@",
"link",
"#",
"on",
"downstream",
"format",
"changed",
"(",
"int",
",",
"media",
"period",
"id",
",",
"media",
"load",
"data",
")",
"}"
] | [
"public",
"void",
"downstream",
"format",
"changed",
"(",
"int",
"track",
"type",
",",
"@",
"nullable",
"format",
"track",
"format",
",",
"int",
"track",
"selection",
"reason",
",",
"@",
"nullable",
"object",
"track",
"selection",
"data",
",",
"long",
"media",
"time",
"us",
")",
"{",
"downstream",
"format",
"changed",
"(",
"new",
"media",
"load",
"data",
"(",
"c",
"data",
"type",
"media",
",",
"track",
"type",
",",
"track",
"format",
",",
"track",
"selection",
"reason",
",",
"track",
"selection",
"data",
",",
"adjust",
"media",
"time",
"(",
"media",
"time",
"us",
")",
",",
"/",
"*",
"media",
"end",
"time",
"ms",
"=",
"*",
"/",
"c",
"time",
"unset",
")",
")",
";",
"}"
] |
[
"get",
"the",
"maximum",
"resource",
"allocation",
"for",
"the",
"given",
"queue",
"if",
"the",
"max",
"is",
"not",
"set",
",",
"return",
"the",
"default",
"max"
] | [
"configurable",
"resource",
"get",
"max",
"resources",
"(",
"string",
"queue",
")",
"{",
"configurable",
"resource",
"max",
"queue",
"resource",
"=",
"max",
"queue",
"resources",
"get",
"(",
"queue",
")",
";",
"if",
"(",
"max",
"queue",
"resource",
"=",
"=",
"null",
")",
"{",
"max",
"queue",
"resource",
"=",
"queue",
"max",
"resources",
"default",
";",
"}",
"return",
"max",
"queue",
"resource",
";",
"}"
] |
[
"return",
"a",
"mutable",
"map",
"with",
"the",
"cookies",
"to",
"send",
"to",
"the",
"server"
] | [
"multi",
"value",
"map",
"<",
"string",
",",
"response",
"cookie",
">",
"get",
"cookies",
"(",
")",
";"
] |
[
"utility",
"to",
"retrieve",
"a",
"specified",
"key",
"from",
"a",
"configuration",
"throw",
"exception",
"if",
"not",
"found"
] | [
"public",
"static",
"long",
"get",
"long",
"(",
"configuration",
"configuration",
",",
"string",
"label",
")",
"{",
"long",
"value",
"=",
"configuration",
"get",
"long",
"(",
"label",
",",
"-",
"1",
")",
";",
"assert",
"value",
">",
"=",
"0",
":",
"\"",
"couldn",
"'",
"t",
"find",
"\"",
"+",
"label",
";",
"return",
"value",
";",
"}"
] |
[
"keep",
"trying",
"a",
"limited",
"number",
"of",
"times",
",",
"waiting",
"a",
"growing",
"amount",
"of",
"time",
"between",
"attempts",
",",
"and",
"then",
"fail",
"by",
"re",
"-",
"throwing",
"the",
"exception",
"the",
"time",
"between",
"attempts",
"is",
"<",
"code",
">",
"sleep",
"time",
"<",
"code",
">",
"mutliplied",
"by",
"a",
"random",
"number",
"in",
"the",
"range",
"of",
"[",
"0",
",",
"2",
"to",
"the",
"number",
"of",
"retries",
")"
] | [
"public",
"static",
"final",
"retry",
"policy",
"exponential",
"backoff",
"retry",
"(",
"int",
"max",
"retries",
",",
"long",
"sleep",
"time",
",",
"time",
"unit",
"time",
"unit",
")",
"{",
"return",
"new",
"exponential",
"backoff",
"retry",
"(",
"max",
"retries",
",",
"sleep",
"time",
",",
"time",
"unit",
")",
";",
"}"
] |
[
"tests",
"incremental",
"mount",
"behaviour",
"of",
"a",
"horizontal",
"stack",
"of",
"components",
"with",
"a",
"view",
"mount",
"type"
] | [
"public",
"void",
"test",
"incremental",
"mount",
"horizontal",
"view",
"stack",
"(",
")",
"{",
"final",
"test",
"component",
"child",
"1",
"=",
"create",
"(",
"m",
"context",
")",
"build",
"(",
")",
";",
"final",
"test",
"component",
"child",
"2",
"=",
"create",
"(",
"m",
"context",
")",
"build",
"(",
")",
";",
"final",
"component",
"root",
"=",
"row",
"create",
"(",
"m",
"context",
")",
"child",
"(",
"wrapper",
"create",
"(",
"m",
"context",
")",
"delegate",
"(",
"child",
"1",
")",
"width",
"px",
"(",
"10",
")",
"height",
"px",
"(",
"10",
")",
")",
"child",
"(",
"wrapper",
"create",
"(",
"m",
"context",
")",
"delegate",
"(",
"child",
"2",
")",
"width",
"px",
"(",
"10",
")",
"height",
"px",
"(",
"10",
")",
")",
"build",
"(",
")",
";",
"m",
"litho",
"view",
"rule",
"set",
"root",
"(",
"root",
")",
"attach",
"to",
"window",
"(",
")",
"set",
"size",
"specs",
"(",
"make",
"size",
"spec",
"(",
"1000",
",",
"exactly",
")",
",",
"make",
"size",
"spec",
"(",
"1000",
",",
"exactly",
")",
")",
"measure",
"(",
")",
"layout",
"(",
")",
";",
"final",
"litho",
"view",
"litho",
"view",
"=",
"m",
"litho",
"view",
"rule",
"get",
"litho",
"view",
"(",
")",
";",
"litho",
"view",
"get",
"component",
"tree",
"(",
")",
"mount",
"component",
"(",
"new",
"rect",
"(",
"-",
"10",
",",
"0",
",",
"-",
"5",
",",
"10",
")",
",",
"true",
")",
";",
"assert",
"that",
"(",
"child",
"1",
"is",
"mounted",
"(",
")",
")",
"is",
"false",
"(",
")",
";",
"assert",
"that",
"(",
"child",
"2",
"is",
"mounted",
"(",
")",
")",
"is",
"false",
"(",
")",
";",
"litho",
"view",
"get",
"component",
"tree",
"(",
")",
"mount",
"component",
"(",
"new",
"rect",
"(",
"0",
",",
"0",
",",
"5",
",",
"10",
")",
",",
"true",
")",
";",
"assert",
"that",
"(",
"child",
"1",
"is",
"mounted",
"(",
")",
")",
"is",
"true",
"(",
")",
";",
"assert",
"that",
"(",
"child",
"2",
"is",
"mounted",
"(",
")",
")",
"is",
"false",
"(",
")",
";",
"litho",
"view",
"get",
"component",
"tree",
"(",
")",
"mount",
"component",
"(",
"new",
"rect",
"(",
"5",
",",
"0",
",",
"15",
",",
"10",
")",
",",
"true",
")",
";",
"assert",
"that",
"(",
"child",
"1",
"is",
"mounted",
"(",
")",
")",
"is",
"true",
"(",
")",
";",
"assert",
"that",
"(",
"child",
"2",
"is",
"mounted",
"(",
")",
")",
"is",
"true",
"(",
")",
";",
"litho",
"view",
"get",
"component",
"tree",
"(",
")",
"mount",
"component",
"(",
"new",
"rect",
"(",
"15",
",",
"0",
",",
"25",
",",
"10",
")",
",",
"true",
")",
";",
"assert",
"that",
"(",
"child",
"1",
"is",
"mounted",
"(",
")",
")",
"is",
"false",
"(",
")",
";",
"assert",
"that",
"(",
"child",
"2",
"is",
"mounted",
"(",
")",
")",
"is",
"true",
"(",
")",
";",
"litho",
"view",
"get",
"component",
"tree",
"(",
")",
"mount",
"component",
"(",
"new",
"rect",
"(",
"20",
",",
"0",
",",
"30",
",",
"10",
")",
",",
"true",
")",
";",
"assert",
"that",
"(",
"child",
"1",
"is",
"mounted",
"(",
")",
")",
"is",
"false",
"(",
")",
";",
"assert",
"that",
"(",
"child",
"2",
"is",
"mounted",
"(",
")",
")",
"is",
"false",
"(",
")",
";",
"}"
] |
[
"this",
"method",
"is",
"deprecated",
"and",
"will",
"be",
"removed",
"in",
"the",
"future",
"releases",
"handle",
"async",
"db",
"operation",
"in",
"your",
"own",
"logic",
"instead"
] | [
"public",
"<",
"t",
">",
"find",
"executor",
"<",
"t",
">",
"find",
"first",
"async",
"(",
"final",
"class",
"<",
"t",
">",
"model",
"class",
",",
"final",
"boolean",
"is",
"eager",
")",
"{",
"final",
"find",
"executor",
"<",
"t",
">",
"executor",
"=",
"new",
"find",
"executor",
"<",
">",
"(",
")",
";",
"runnable",
"runnable",
"=",
"new",
"runnable",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"run",
"(",
")",
"{",
"synchronized",
"(",
"lite",
"pal",
"support",
"class",
")",
"{",
"final",
"t",
"t",
"=",
"find",
"first",
"(",
"model",
"class",
",",
"is",
"eager",
")",
";",
"if",
"(",
"executor",
"get",
"listener",
"(",
")",
"!",
"=",
"null",
")",
"{",
"operator",
"get",
"handler",
"(",
")",
"post",
"(",
"new",
"runnable",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"run",
"(",
")",
"{",
"executor",
"get",
"listener",
"(",
")",
"on",
"finish",
"(",
"t",
")",
";",
"}",
"}",
")",
";",
"}",
"}",
"}",
"}",
";",
"executor",
"submit",
"(",
"runnable",
")",
";",
"return",
"executor",
";",
"}"
] |
[
"verify",
"local",
"node",
"selection",
"with",
"using",
"d",
"f",
"s",
"network",
"topology"
] | [
"public",
"void",
"test",
"placement",
"with",
"d",
"f",
"s",
"network",
"topology",
"(",
")",
"throws",
"exception",
"{",
"configuration",
"conf",
"=",
"new",
"hdfs",
"configuration",
"(",
")",
";",
"final",
"string",
"[",
"]",
"racks",
"=",
"{",
"\"",
"/",
"rack0",
"\"",
",",
"\"",
"/",
"rack0",
"\"",
",",
"\"",
"/",
"rack2",
"\"",
",",
"\"",
"/",
"rack3",
"\"",
",",
"\"",
"/",
"rack2",
"\"",
"}",
";",
"final",
"string",
"[",
"]",
"hosts",
"=",
"{",
"\"",
"/",
"host",
"0",
"\"",
",",
"\"",
"/",
"host",
"1",
"\"",
",",
"\"",
"/",
"host",
"2",
"\"",
",",
"\"",
"/",
"host",
"3",
"\"",
",",
"\"",
"/",
"host",
"4",
"\"",
"}",
";",
"/",
"/",
"enables",
"d",
"f",
"s",
"network",
"topology",
"conf",
"set",
"boolean",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"use",
"dfs",
"network",
"topology",
"key",
",",
"true",
")",
";",
"conf",
"set",
"long",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"block",
"size",
"key",
",",
"default",
"block",
"size",
")",
";",
"conf",
"set",
"int",
"(",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"bytes",
"per",
"checksum",
"key",
",",
"default",
"block",
"size",
"/",
"2",
")",
";",
"if",
"(",
"cluster",
"!",
"=",
"null",
")",
"{",
"cluster",
"shutdown",
"(",
")",
";",
"}",
"cluster",
"=",
"new",
"mini",
"d",
"f",
"s",
"cluster",
"builder",
"(",
"conf",
")",
"num",
"data",
"nodes",
"(",
"5",
")",
"racks",
"(",
"racks",
")",
"hosts",
"(",
"hosts",
")",
"build",
"(",
")",
";",
"cluster",
"wait",
"active",
"(",
")",
";",
"name",
"node",
"rpc",
"=",
"cluster",
"get",
"name",
"node",
"rpc",
"(",
")",
";",
"namesystem",
"=",
"cluster",
"get",
"namesystem",
"(",
")",
";",
"datanode",
"manager",
"dm",
"=",
"namesystem",
"get",
"block",
"manager",
"(",
")",
"get",
"datanode",
"manager",
"(",
")",
";",
"assert",
"true",
"(",
"dm",
"get",
"network",
"topology",
"(",
")",
"instanceof",
"d",
"f",
"s",
"network",
"topology",
")",
";",
"string",
"client",
"machine",
"=",
"\"",
"/",
"host",
"3",
"\"",
";",
"string",
"client",
"rack",
"=",
"\"",
"/",
"rack3",
"\"",
";",
"string",
"src",
"=",
"\"",
"/",
"test",
"\"",
";",
"/",
"/",
"create",
"the",
"file",
"with",
"client",
"machine",
"hdfs",
"file",
"status",
"file",
"status",
"=",
"namesystem",
"start",
"file",
"(",
"src",
",",
"perm",
",",
"client",
"machine",
",",
"client",
"machine",
",",
"enum",
"set",
"of",
"(",
"create",
"flag",
"create",
")",
",",
"true",
",",
"replication",
"factor",
",",
"default",
"block",
"size",
",",
"null",
",",
"null",
",",
"null",
",",
"false",
")",
";",
"located",
"block",
"located",
"block",
"=",
"name",
"node",
"rpc",
"add",
"block",
"(",
"src",
",",
"client",
"machine",
",",
"null",
",",
"null",
",",
"file",
"status",
"get",
"file",
"id",
"(",
")",
",",
"null",
",",
"null",
")",
";",
"assert",
"equals",
"(",
"\"",
"block",
"should",
"be",
"allocated",
"sufficient",
"locations",
"\"",
",",
"replication",
"factor",
",",
"located",
"block",
"get",
"locations",
"(",
")",
"length",
")",
";",
"assert",
"equals",
"(",
"\"",
"first",
"datanode",
"should",
"be",
"rack",
"local",
"\"",
",",
"client",
"rack",
",",
"located",
"block",
"get",
"locations",
"(",
")",
"[",
"0",
"]",
"get",
"network",
"location",
"(",
")",
")",
";",
"name",
"node",
"rpc",
"abandon",
"block",
"(",
"located",
"block",
"get",
"block",
"(",
")",
",",
"file",
"status",
"get",
"file",
"id",
"(",
")",
",",
"src",
",",
"client",
"machine",
")",
";",
"}"
] |
[
"get",
"the",
"named",
"non",
"-",
"terminal"
] | [
"public",
"nt",
"get",
"non",
"terminal",
"(",
"string",
"name",
")",
"{",
"return",
"nonterminals",
"get",
"(",
"name",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"array",
"of",
"string",
"'"
] | [
"public",
"void",
"array",
"of",
"string",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"array",
"of",
"string",
"}"
] |
[
"returns",
"a",
"read",
"-",
"only",
"view",
"of",
"all",
"system",
"properties"
] | [
"public",
"static",
"dictionary",
"<",
"object",
",",
"object",
">",
"get",
"system",
"properties",
"(",
")",
"{",
"security",
"manager",
"sm",
"=",
"system",
"get",
"security",
"manager",
"(",
")",
";",
"if",
"(",
"sm",
"!",
"=",
"null",
")",
"{",
"sm",
"check",
"property",
"access",
"(",
"\"",
"*",
"\"",
")",
";",
"}",
"return",
"system",
"properties",
";",
"}"
] |
[
"send",
"data",
"to",
"the",
"target",
"based",
"on",
"the",
"given",
"selector"
] | [
"public",
"void",
"send",
"(",
"string",
"next",
"work",
"name",
",",
"stream",
"data",
"stream",
"data",
",",
"selector",
"selector",
")",
"{",
"remote",
"client",
"manager",
"client",
"manager",
"=",
"module",
"manager",
"find",
"(",
"core",
"module",
"name",
")",
"provider",
"(",
")",
"get",
"service",
"(",
"remote",
"client",
"manager",
"class",
")",
";",
"remote",
"client",
"remote",
"client",
"=",
"null",
";",
"list",
"<",
"remote",
"client",
">",
"client",
"list",
"=",
"client",
"manager",
"get",
"remote",
"client",
"(",
")",
";",
"if",
"(",
"client",
"list",
"size",
"(",
")",
"=",
"=",
"0",
")",
"{",
"logger",
"warn",
"(",
"\"",
"there",
"is",
"no",
"available",
"remote",
"server",
"for",
"now",
",",
"ignore",
"the",
"streaming",
"data",
"until",
"the",
"cluster",
"metadata",
"initialized",
"\"",
")",
";",
"return",
";",
"}",
"switch",
"(",
"selector",
")",
"{",
"case",
"hash",
"code",
":",
"remote",
"client",
"=",
"hash",
"code",
"selector",
"select",
"(",
"client",
"list",
",",
"stream",
"data",
")",
";",
"break",
";",
"case",
"rolling",
":",
"remote",
"client",
"=",
"rolling",
"selector",
"select",
"(",
"client",
"list",
",",
"stream",
"data",
")",
";",
"break",
";",
"case",
"forever",
"first",
":",
"remote",
"client",
"=",
"forever",
"first",
"selector",
"select",
"(",
"client",
"list",
",",
"stream",
"data",
")",
";",
"break",
";",
"}",
"remote",
"client",
"push",
"(",
"next",
"work",
"name",
",",
"stream",
"data",
")",
";",
"}"
] |
[
"encodes",
"the",
"specified",
"range",
"of",
"the",
"specified",
"byte",
"array",
",",
"and",
"returns",
"the",
"encoded",
"{",
"@",
"code",
"string",
"}"
] | [
"public",
"final",
"string",
"encode",
"(",
"byte",
"[",
"]",
"bytes",
",",
"int",
"off",
",",
"int",
"len",
")",
"{",
"check",
"position",
"indexes",
"(",
"off",
",",
"off",
"+",
"len",
",",
"bytes",
"length",
")",
";",
"string",
"builder",
"result",
"=",
"new",
"string",
"builder",
"(",
"max",
"encoded",
"size",
"(",
"len",
")",
")",
";",
"try",
"{",
"encode",
"to",
"(",
"result",
",",
"bytes",
",",
"off",
",",
"len",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"impossible",
")",
"{",
"throw",
"new",
"assertion",
"error",
"(",
"impossible",
")",
";",
"}",
"return",
"result",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"returns",
"a",
"range",
"that",
"contains",
"every",
"value",
"of",
"type",
"{",
"@",
"code",
"c",
"}"
] | [
"public",
"static",
"<",
"c",
"extends",
"comparable",
"<",
"?",
">",
">",
"range",
"<",
"c",
">",
"all",
"(",
")",
"{",
"return",
"(",
"range",
")",
"all",
";",
"}"
] |
[
"builds",
"the",
"action",
"as",
"configured",
"and",
"performs",
"some",
"validations",
"on",
"the",
"action",
"uses",
"given",
"{",
"@",
"link",
"consumer",
"}",
"to",
"collect",
"validation",
"errors"
] | [
"public",
"cpp",
"compile",
"action",
"build",
"and",
"verify",
"(",
"consumer",
"<",
"string",
">",
"error",
"collector",
")",
"{",
"/",
"/",
"this",
"must",
"be",
"set",
"either",
"to",
"false",
"or",
"true",
"by",
"cpp",
"semantics",
",",
"otherwise",
"someone",
"forgot",
"to",
"call",
"/",
"/",
"finalize",
"compile",
"action",
"builder",
"on",
"this",
"builder",
"preconditions",
"check",
"not",
"null",
"(",
"should",
"scan",
"includes",
")",
";",
"preconditions",
"check",
"not",
"null",
"(",
"feature",
"configuration",
")",
";",
"boolean",
"use",
"header",
"modules",
"=",
"use",
"header",
"modules",
"(",
")",
";",
"if",
"(",
"feature",
"configuration",
"action",
"is",
"configured",
"(",
"get",
"action",
"name",
"(",
")",
")",
")",
"{",
"for",
"(",
"string",
"execution",
"requirement",
":",
"feature",
"configuration",
"get",
"tool",
"requirements",
"for",
"action",
"(",
"get",
"action",
"name",
"(",
")",
")",
")",
"{",
"execution",
"info",
"put",
"(",
"execution",
"requirement",
",",
"\"",
"\"",
")",
";",
"}",
"}",
"else",
"{",
"error",
"collector",
"accept",
"(",
"string",
"format",
"(",
"\"",
"expected",
"action",
"config",
"for",
"'",
"%",
"s",
"'",
"to",
"be",
"configured",
"\"",
",",
"get",
"action",
"name",
"(",
")",
")",
")",
";",
"}",
"nested",
"set",
"<",
"artifact",
">",
"real",
"mandatory",
"inputs",
"=",
"build",
"mandatory",
"inputs",
"(",
")",
";",
"nested",
"set",
"<",
"artifact",
">",
"prunable",
"headers",
"=",
"build",
"prunable",
"headers",
"(",
")",
";",
"configuration",
"modify",
"execution",
"info",
"(",
"execution",
"info",
",",
"cpp",
"compile",
"action",
"action",
"name",
"to",
"mnemonic",
"(",
"get",
"action",
"name",
"(",
")",
",",
"feature",
"configuration",
",",
"cpp",
"configuration",
"use",
"cpp",
"compile",
"header",
"mnemonic",
"(",
")",
")",
")",
";",
"/",
"/",
"copying",
"the",
"collections",
"is",
"needed",
"to",
"make",
"the",
"builder",
"reusable",
"cpp",
"compile",
"action",
"action",
";",
"action",
"=",
"new",
"cpp",
"compile",
"action",
"(",
"owner",
",",
"feature",
"configuration",
",",
"variables",
",",
"source",
"file",
",",
"cpp",
"configuration",
",",
"shareable",
",",
"should",
"scan",
"includes",
",",
"use",
"pic",
",",
"use",
"header",
"modules",
",",
"real",
"mandatory",
"inputs",
",",
"build",
"inputs",
"for",
"invalidation",
"(",
")",
",",
"get",
"builtin",
"include",
"files",
"(",
")",
",",
"prunable",
"headers",
",",
"output",
"file",
",",
"dotd",
"file",
",",
"gcno",
"file",
",",
"dwo",
"file",
",",
"lto",
"indexing",
"file",
",",
"env",
",",
"cc",
"compilation",
"context",
",",
"copts",
"filter",
",",
"immutable",
"list",
"copy",
"of",
"(",
"additional",
"include",
"scanning",
"roots",
")",
",",
"action",
"class",
"id",
",",
"immutable",
"map",
"copy",
"of",
"(",
"execution",
"info",
")",
",",
"get",
"action",
"name",
"(",
")",
",",
"cpp",
"semantics",
",",
"builtin",
"include",
"directories",
",",
"grep",
"includes",
")",
";",
"return",
"action",
";",
"}"
] |
[
"register",
"fields",
"that",
"are",
"required",
"for",
"each",
"binding",
"process",
"if",
"one",
"of",
"the",
"specified",
"fields",
"is",
"not",
"contained",
"in",
"the",
"list",
"of",
"incoming",
"property",
"values",
",",
"a",
"corresponding",
"\"",
"missing",
"field",
"\"",
"error",
"will",
"be",
"created",
",",
"with",
"error",
"code",
"\"",
"required",
"\"",
"(",
"by",
"the",
"default",
"binding",
"error",
"processor",
")"
] | [
"public",
"void",
"set",
"required",
"fields",
"(",
"@",
"nullable",
"string",
"required",
"fields",
")",
"{",
"this",
"required",
"fields",
"=",
"property",
"accessor",
"utils",
"canonical",
"property",
"names",
"(",
"required",
"fields",
")",
";",
"if",
"(",
"logger",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"logger",
"debug",
"(",
"\"",
"data",
"binder",
"requires",
"binding",
"of",
"required",
"fields",
"[",
"\"",
"+",
"string",
"utils",
"array",
"to",
"comma",
"delimited",
"string",
"(",
"required",
"fields",
")",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"}"
] |
[
"specify",
"the",
"uri",
"for",
"the",
"request",
"using",
"a",
"uri",
"template",
"and",
"uri",
"variables",
"if",
"a",
"{",
"@",
"link",
"uri",
"builder",
"factory",
"}",
"was",
"configured",
"for",
"the",
"client",
"(",
"e",
"g",
"with",
"a",
"base",
"uri",
")",
"it",
"will",
"be",
"used",
"to",
"expand",
"the",
"uri",
"template"
] | [
"s",
"uri",
"(",
"string",
"uri",
",",
"object",
"uri",
"variables",
")",
";"
] |
[
"get",
"map",
"number"
] | [
"public",
"map",
"<",
"string",
",",
"big",
"decimal",
">",
"get",
"map",
"number",
"(",
")",
"{",
"return",
"map",
"number",
";",
"}"
] |
[
"override",
"the",
"default",
"jackson",
"smile",
"{",
"@",
"code",
"encoder",
"}"
] | [
"void",
"jackson",
"2",
"smile",
"encoder",
"(",
"encoder",
"<",
"?",
">",
"encoder",
")",
";"
] |
[
"get",
"snake",
"case"
] | [
"public",
"integer",
"get",
"snake",
"case",
"(",
")",
"{",
"return",
"snake",
"case",
";",
"}"
] |
[
"return",
"a",
"{",
"@",
"code",
"request",
"predicate",
"}",
"that",
"matches",
"if",
"the",
"request",
"'",
"s",
"parameter",
"of",
"the",
"given",
"name",
"has",
"the",
"given",
"value"
] | [
"public",
"static",
"request",
"predicate",
"param",
"(",
"string",
"name",
",",
"string",
"value",
")",
"{",
"return",
"new",
"param",
"predicate",
"(",
"name",
",",
"value",
")",
";",
"}"
] |
[
"disposes",
"this",
"vertex",
"data",
"and",
"all",
"its",
"associated",
"open",
"g",
"l",
"resources"
] | [
"public",
"void",
"dispose",
"(",
")",
";"
] |
[
"get",
"a",
"mapper",
"interface",
"type",
"that",
"specified",
"provider"
] | [
"public",
"class",
"<",
"?",
">",
"get",
"mapper",
"type",
"(",
")",
"{",
"return",
"mapper",
"type",
";",
"}"
] |
[
"find",
"pet",
"by",
"id",
"returns",
"a",
"single",
"pet"
] | [
"public",
"void",
"get",
"pet",
"by",
"id",
"test",
"(",
")",
"throws",
"api",
"exception",
"{",
"long",
"pet",
"id",
"=",
"null",
";",
"pet",
"response",
"=",
"api",
"get",
"pet",
"by",
"id",
"(",
"pet",
"id",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
] |
[
"create",
"a",
"append",
"file",
"request",
"adds",
"the",
"acl",
"and",
"metadata"
] | [
"static",
"write",
"file",
"request",
"new",
"append",
"file",
"request",
"(",
"final",
"o",
"b",
"s",
"file",
"system",
"owner",
",",
"final",
"string",
"key",
",",
"final",
"long",
"record",
"position",
",",
"final",
"file",
"tmp",
"file",
")",
"throws",
"i",
"o",
"exception",
"{",
"preconditions",
"check",
"not",
"null",
"(",
"key",
")",
";",
"preconditions",
"check",
"not",
"null",
"(",
"tmp",
"file",
")",
";",
"obs",
"f",
"s",
"attribute",
"obs",
"fs",
"attribute",
";",
"try",
"{",
"get",
"attribute",
"request",
"get",
"attribute",
"req",
"=",
"new",
"get",
"attribute",
"request",
"(",
"owner",
"get",
"bucket",
"(",
")",
",",
"key",
")",
";",
"obs",
"fs",
"attribute",
"=",
"owner",
"get",
"obs",
"client",
"(",
")",
"get",
"attribute",
"(",
"get",
"attribute",
"req",
")",
";",
"}",
"catch",
"(",
"obs",
"exception",
"e",
")",
"{",
"throw",
"translate",
"exception",
"(",
"\"",
"get",
"attribute",
"request",
"\"",
",",
"key",
",",
"e",
")",
";",
"}",
"long",
"append",
"position",
"=",
"math",
"max",
"(",
"record",
"position",
",",
"obs",
"fs",
"attribute",
"get",
"content",
"length",
"(",
")",
")",
";",
"if",
"(",
"record",
"position",
"!",
"=",
"obs",
"fs",
"attribute",
"get",
"content",
"length",
"(",
")",
")",
"{",
"log",
"warn",
"(",
"\"",
"append",
"url",
"[",
"{",
"}",
"]",
"position",
"[",
"{",
"}",
"]",
",",
"file",
"content",
"length",
"[",
"{",
"}",
"]",
"not",
"\"",
"+",
"\"",
"equal",
"to",
"record",
"position",
"[",
"{",
"}",
"]",
"\"",
",",
"key",
",",
"append",
"position",
",",
"obs",
"fs",
"attribute",
"get",
"content",
"length",
"(",
")",
",",
"record",
"position",
")",
";",
"}",
"write",
"file",
"request",
"write",
"file",
"req",
"=",
"new",
"write",
"file",
"request",
"(",
"owner",
"get",
"bucket",
"(",
")",
",",
"key",
",",
"tmp",
"file",
",",
"append",
"position",
")",
";",
"write",
"file",
"req",
"set",
"acl",
"(",
"owner",
"get",
"canned",
"a",
"c",
"l",
"(",
")",
")",
";",
"return",
"write",
"file",
"req",
";",
"}"
] |
[
"put",
"faketest",
"-",
"query",
"-",
"paramters",
"to",
"test",
"the",
"collection",
"format",
"in",
"query",
"parameters"
] | [
"default",
"response",
"entity",
"<",
"void",
">",
"test",
"query",
"parameter",
"collection",
"format",
"(",
"list",
"<",
"string",
">",
"pipe",
",",
"list",
"<",
"string",
">",
"ioutil",
",",
"list",
"<",
"string",
">",
"http",
",",
"list",
"<",
"string",
">",
"url",
",",
"list",
"<",
"string",
">",
"context",
")",
"{",
"return",
"new",
"response",
"entity",
"<",
">",
"(",
"http",
"status",
"not",
"implemented",
")",
";",
"}"
] |
[
"set",
"an",
"implementation",
"of",
"the",
"{",
"@",
"link",
"javax",
"xml",
"transform",
"error",
"listener",
"}",
"interface",
"for",
"custom",
"handling",
"of",
"transformation",
"errors",
"and",
"warnings",
"if",
"not",
"set",
",",
"a",
"default",
"{",
"@",
"link",
"org",
"springframework",
"util",
"xml",
"simple",
"transform",
"error",
"listener",
"}",
"is",
"used",
"that",
"simply",
"logs",
"warnings",
"using",
"the",
"logger",
"instance",
"of",
"the",
"view",
"class",
",",
"and",
"rethrows",
"errors",
"to",
"discontinue",
"the",
"xml",
"transformation"
] | [
"public",
"void",
"set",
"error",
"listener",
"(",
"error",
"listener",
"error",
"listener",
")",
"{",
"this",
"error",
"listener",
"=",
"error",
"listener",
";",
"}"
] |
[
"return",
"\"",
"streaming",
"\"",
"media",
"types",
"for",
"which",
"flushing",
"should",
"be",
"performed",
"automatically",
"vs",
"at",
"the",
"end",
"of",
"the",
"input",
"stream"
] | [
"list",
"<",
"media",
"type",
">",
"get",
"streaming",
"media",
"types",
"(",
")",
";"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"sends",
"an",
"exit",
"code",
"to",
"the",
"command",
",",
"which",
"will",
"then",
"return",
"with",
"it",
"if",
"it",
"is",
"still",
"running"
] | [
"void",
"request",
"exit",
"with",
"(",
"detailed",
"exit",
"code",
"detailed",
"exit",
"code",
")",
"{",
"detailed",
"code",
"queue",
"offer",
"(",
"detailed",
"exit",
"code",
")",
";",
"}"
] |
[
"get",
"user",
"by",
"user",
"name",
"<",
"b",
">",
"200",
"<",
"b",
">",
"-",
"successful",
"operation",
"<",
"b",
">",
"400",
"<",
"b",
">",
"-",
"invalid",
"username",
"supplied",
"<",
"b",
">",
"404",
"<",
"b",
">",
"-",
"user",
"not",
"found"
] | [
"public",
"user",
"get",
"user",
"by",
"name",
"(",
"string",
"username",
",",
"map",
"<",
"string",
",",
"object",
">",
"params",
")",
"throws",
"i",
"o",
"exception",
"{",
"http",
"response",
"response",
"=",
"get",
"user",
"by",
"name",
"for",
"http",
"response",
"(",
"username",
",",
"params",
")",
";",
"type",
"reference",
"<",
"user",
">",
"type",
"ref",
"=",
"new",
"type",
"reference",
"<",
"user",
">",
"(",
")",
"{",
"}",
";",
"return",
"api",
"client",
"get",
"object",
"mapper",
"(",
")",
"read",
"value",
"(",
"response",
"get",
"content",
"(",
")",
",",
"type",
"ref",
")",
";",
"}"
] |
[
"recursively",
"make",
"a",
"path"
] | [
"public",
"void",
"zk",
"mk",
"parent",
"path",
"(",
"string",
"path",
",",
"list",
"<",
"acl",
">",
"acl",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"/",
"split",
"path",
"into",
"elements",
"zk",
"mk",
"path",
"(",
"registry",
"path",
"utils",
"parent",
"of",
"(",
"path",
")",
",",
"create",
"mode",
"persistent",
",",
"true",
",",
"acl",
")",
";",
"}"
] |
[
"creates",
"a",
"new",
"buffer",
"which",
"wraps",
"the",
"specified",
"memory",
"address",
"if",
"{",
"@",
"code",
"do",
"free",
"}",
"is",
"true",
"the",
"memory",
"address",
"will",
"automatically",
"be",
"freed",
"once",
"the",
"reference",
"count",
"of",
"the",
"{",
"@",
"link",
"byte",
"buf",
"}",
"reaches",
"{",
"@",
"code",
"0",
"}"
] | [
"public",
"static",
"byte",
"buf",
"wrapped",
"buffer",
"(",
"long",
"memory",
"address",
",",
"int",
"size",
",",
"boolean",
"do",
"free",
")",
"{",
"return",
"new",
"wrapped",
"unpooled",
"unsafe",
"direct",
"byte",
"buf",
"(",
"alloc",
",",
"memory",
"address",
",",
"size",
",",
"do",
"free",
")",
";",
"}"
] |
[
"emit",
"a",
"soft",
"error",
"if",
"the",
"size",
"between",
"m",
"placeholders",
"and",
"m",
"next",
"data",
"aren",
"'",
"t",
"the",
"same"
] | [
"private",
"void",
"log",
"error",
"for",
"inconsistent",
"size",
"(",
"component",
"context",
"c",
")",
"{",
"final",
"string",
"builder",
"message",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"message",
"append",
"(",
"\"",
"inconsistent",
"size",
"between",
"m",
"placeholders",
"(",
"\"",
")",
"append",
"(",
"m",
"placeholders",
"size",
"(",
")",
")",
"append",
"(",
"\"",
")",
"and",
"m",
"next",
"data",
"(",
"\"",
")",
"append",
"(",
"m",
"next",
"data",
"size",
"(",
")",
")",
"append",
"(",
"\"",
")",
";",
"\"",
")",
";",
"message",
"append",
"(",
"\"",
"m",
"operations",
":",
"[",
"\"",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
",",
"size",
"=",
"m",
"operations",
"size",
"(",
")",
";",
"i",
"<",
"size",
";",
"i",
"+",
"+",
")",
"{",
"final",
"operation",
"operation",
"=",
"m",
"operations",
"get",
"(",
"i",
")",
";",
"message",
"append",
"(",
"\"",
"[",
"type",
"=",
"\"",
")",
"append",
"(",
"operation",
"get",
"type",
"(",
")",
")",
"append",
"(",
"\"",
",",
"index",
"=",
"\"",
")",
"append",
"(",
"operation",
"get",
"index",
"(",
")",
")",
"append",
"(",
"\"",
",",
"to",
"index",
"=",
"\"",
")",
"append",
"(",
"operation",
"get",
"to",
"index",
"(",
")",
")",
";",
"if",
"(",
"operation",
"m",
"component",
"containers",
"!",
"=",
"null",
")",
"{",
"message",
"append",
"(",
"\"",
",",
"count",
"=",
"\"",
")",
"append",
"(",
"operation",
"m",
"component",
"containers",
"size",
"(",
")",
")",
";",
"}",
"message",
"append",
"(",
"\"",
"]",
",",
"\"",
")",
";",
"}",
"message",
"append",
"(",
"\"",
"]",
";",
"\"",
")",
";",
"message",
"append",
"(",
"\"",
"m",
"next",
"data",
":",
"[",
"\"",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
",",
"size",
"=",
"m",
"next",
"data",
"size",
"(",
")",
";",
"i",
"<",
"size",
";",
"i",
"+",
"+",
")",
"{",
"message",
"append",
"(",
"\"",
"[",
"\"",
")",
"append",
"(",
"m",
"next",
"data",
"get",
"(",
"i",
")",
")",
"append",
"(",
"\"",
"]",
",",
"\"",
")",
";",
"}",
"message",
"append",
"(",
"\"",
"]",
"\"",
")",
";",
"components",
"reporter",
"emit",
"message",
"(",
"components",
"reporter",
"log",
"level",
"error",
",",
"inconsistent",
"size",
",",
"message",
"to",
"string",
"(",
")",
")",
";",
"}"
] |
[
"add",
"both",
"keyed",
"and",
"non",
"-",
"keyed",
"entries",
"for",
"the",
"supplied",
"{",
"@",
"code",
"field",
"}",
"to",
"the",
"supplied",
"field",
"list"
] | [
"protected",
"void",
"build",
"field",
"list",
"(",
"string",
"field",
",",
"list",
"<",
"string",
">",
"field",
"list",
")",
"{",
"field",
"list",
"add",
"(",
"field",
")",
";",
"string",
"plain",
"field",
"=",
"field",
";",
"int",
"key",
"index",
"=",
"plain",
"field",
"last",
"index",
"of",
"(",
"'",
"[",
"'",
")",
";",
"while",
"(",
"key",
"index",
"!",
"=",
"-",
"1",
")",
"{",
"int",
"end",
"key",
"index",
"=",
"plain",
"field",
"index",
"of",
"(",
"'",
"]",
"'",
",",
"key",
"index",
")",
";",
"if",
"(",
"end",
"key",
"index",
"!",
"=",
"-",
"1",
")",
"{",
"plain",
"field",
"=",
"plain",
"field",
"substring",
"(",
"0",
",",
"key",
"index",
")",
"+",
"plain",
"field",
"substring",
"(",
"end",
"key",
"index",
"+",
"1",
")",
";",
"field",
"list",
"add",
"(",
"plain",
"field",
")",
";",
"key",
"index",
"=",
"plain",
"field",
"last",
"index",
"of",
"(",
"'",
"[",
"'",
")",
";",
"}",
"else",
"{",
"key",
"index",
"=",
"-",
"1",
";",
"}",
"}",
"}"
] |
[
"returns",
"the",
"result",
"of",
"{",
"@",
"link",
"equivalence",
"#",
"hash",
"(",
"object",
")",
"}",
"applied",
"to",
"the",
"wrapped",
"reference"
] | [
"public",
"int",
"hash",
"code",
"(",
")",
"{",
"return",
"equivalence",
"hash",
"(",
"reference",
")",
";",
"}"
] |
[
"overrides",
"the",
"base",
"class",
"behavior",
"to",
"enforce",
"running",
"in",
"an",
"application",
"context",
"all",
"accessors",
"will",
"throw",
"illegal",
"state",
"exception",
"if",
"not",
"running",
"in",
"a",
"context"
] | [
"protected",
"boolean",
"is",
"context",
"required",
"(",
")",
"{",
"return",
"true",
";",
"}"
] |
[
"the",
"{",
"@",
"code",
"to",
"string",
"(",
")",
"}",
"of",
"{",
"@",
"link",
"component",
"}",
"implementations",
"appear",
"in",
"health",
"check",
"endpoints",
"since",
"these",
"are",
"likely",
"to",
"be",
"exposed",
"in",
"logs",
"and",
"other",
"monitoring",
"tools",
",",
"care",
"should",
"be",
"taken",
"to",
"ensure",
"{",
"@",
"code",
"to",
"string",
"(",
")",
"}",
"output",
"is",
"a",
"reasonable",
"length",
"and",
"does",
"not",
"contain",
"sensitive",
"information"
] | [
"@",
"test",
"public",
"void",
"to",
"string",
"contains",
"only",
"summary",
"information",
"(",
")",
"{",
"assert",
"that",
"(",
"collector",
")",
"has",
"to",
"string",
"(",
"string",
"format",
"(",
"\"",
"active",
"m",
"q",
"collector",
"{",
"broker",
"u",
"r",
"l",
"=",
"%",
"s",
",",
"queue",
"=",
"%",
"s",
"}",
"\"",
",",
"activemq",
"get",
"vm",
"u",
"r",
"l",
"(",
")",
",",
"test",
"name",
"get",
"method",
"name",
"(",
")",
")",
")",
";",
"}"
] |
[
"launch",
"the",
"solver",
"on",
"9x",
"1",
"0",
"board",
"and",
"the",
"one",
"sided",
"pentominos",
"this",
"takes",
"about",
"2",
"5",
"hours",
"on",
"20",
"nodes",
"with",
"2",
"cpusnode",
"splits",
"the",
"job",
"into",
"2000",
"maps",
"and",
"1",
"reduce"
] | [
"public",
"static",
"void",
"main",
"(",
"string",
"[",
"]",
"args",
")",
"throws",
"exception",
"{",
"int",
"res",
"=",
"tool",
"runner",
"run",
"(",
"new",
"configuration",
"(",
")",
",",
"new",
"distributed",
"pentomino",
"(",
")",
",",
"args",
")",
";",
"system",
"exit",
"(",
"res",
")",
";",
"}"
] |
[
"return",
"the",
"value",
"of",
"meta",
"-",
"data",
"in",
"receiver"
] | [
"public",
"static",
"string",
"get",
"meta",
"data",
"in",
"receiver",
"(",
"@",
"non",
"null",
"final",
"broadcast",
"receiver",
"receiver",
",",
"@",
"non",
"null",
"final",
"string",
"key",
")",
"{",
"return",
"get",
"meta",
"data",
"in",
"receiver",
"(",
"receiver",
",",
"key",
")",
";",
"}"
] |
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"{",
"@",
"code",
"object",
"}",
"is",
"an",
"{",
"@",
"code",
"immutable",
"int",
"array",
"}",
"containing",
"the",
"same",
"values",
"as",
"this",
"one",
",",
"in",
"the",
"same",
"order"
] | [
"public",
"boolean",
"equals",
"(",
"@",
"nullable",
"object",
"object",
")",
"{",
"if",
"(",
"object",
"=",
"=",
"this",
")",
"{",
"return",
"true",
";",
"}",
"if",
"(",
"!",
"(",
"object",
"instanceof",
"immutable",
"int",
"array",
")",
")",
"{",
"return",
"false",
";",
"}",
"immutable",
"int",
"array",
"that",
"=",
"(",
"immutable",
"int",
"array",
")",
"object",
";",
"if",
"(",
"this",
"length",
"(",
")",
"!",
"=",
"that",
"length",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"length",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"this",
"get",
"(",
"i",
")",
"!",
"=",
"that",
"get",
"(",
"i",
")",
")",
"{",
"return",
"false",
";",
"}",
"}",
"return",
"true",
";",
"}"
] |
[
"finds",
"pets",
"by",
"tags",
"multiple",
"tags",
"can",
"be",
"provided",
"with",
"comma",
"separated",
"strings",
"use",
"tag",
"1",
",",
"tag",
"2",
",",
"tag",
"3",
"for",
"testing"
] | [
"public",
"void",
"find",
"pets",
"by",
"tags",
"(",
"set",
"<",
"string",
">",
"tags",
",",
"handler",
"<",
"async",
"result",
"<",
"set",
"<",
"pet",
">",
">",
">",
"result",
"handler",
")",
"{",
"find",
"pets",
"by",
"tags",
"(",
"tags",
",",
"null",
",",
"result",
"handler",
")",
";",
"}"
] |
[
"first",
"decode",
"base",
"6",
"4",
"string",
"to",
"byte",
"array",
",",
"then",
"use",
"zip",
"input",
"stream",
"to",
"revert",
"the",
"byte",
"array",
"to",
"a",
"string"
] | [
"public",
"static",
"string",
"decompress",
"(",
"final",
"string",
"zipped",
"base",
"6",
"4",
"str",
")",
"{",
"val",
"bytes",
"=",
"encoding",
"utils",
"decode",
"base",
"6",
"4",
"(",
"zipped",
"base",
"6",
"4",
"str",
")",
";",
"try",
"(",
"val",
"zi",
"=",
"new",
"g",
"z",
"i",
"p",
"input",
"stream",
"(",
"new",
"byte",
"array",
"input",
"stream",
"(",
"bytes",
")",
")",
")",
"{",
"return",
"i",
"o",
"utils",
"to",
"string",
"(",
"zi",
",",
"charset",
"default",
"charset",
"(",
")",
")",
";",
"}",
"}"
] |
[
"triggers",
"all",
"registered",
"tasks"
] | [
"public",
"void",
"trigger",
"scheduled",
"tasks",
"(",
")",
"{",
"exec",
"service",
"trigger",
"scheduled",
"tasks",
"(",
")",
";",
"}"
] |
[
"get",
"an",
"entry",
"which",
"must",
"be",
"a",
"directory"
] | [
"protected",
"path",
"metadata",
"get",
"directory",
"(",
"final",
"string",
"path",
"str",
")",
"throws",
"i",
"o",
"exception",
"{",
"path",
"metadata",
"meta",
"=",
"verify",
"cached",
"(",
"path",
"str",
")",
";",
"assert",
"true",
"(",
"path",
"str",
"+",
"\"",
"is",
"not",
"a",
"directory",
":",
"\"",
"+",
"meta",
",",
"meta",
"get",
"file",
"status",
"(",
")",
"is",
"directory",
"(",
")",
")",
";",
"return",
"meta",
";",
"}"
] |
[
"immediately",
"following",
"instantiation",
"of",
"this",
"buffer",
"mgr",
",",
"discard",
"any",
"pre",
"-",
"existing",
"recovery",
"snapshots"
] | [
"public",
"void",
"clear",
"recovery",
"files",
"(",
")",
"{",
"synchronized",
"(",
"snapshot",
"lock",
")",
"{",
"synchronized",
"(",
"this",
")",
"{",
"if",
"(",
"!",
"(",
"source",
"file",
"instanceof",
"local",
"buffer",
"file",
")",
"|",
"|",
"buffer",
"table",
"=",
"=",
"null",
"|",
"|",
"is",
"changed",
"(",
")",
"|",
"|",
"recovery",
"mgr",
"!",
"=",
"null",
"|",
"|",
"lock",
"count",
"!",
"=",
"0",
")",
"{",
"return",
";",
"}",
"new",
"recovery",
"mgr",
"(",
"this",
")",
";",
"/",
"/",
"causes",
"snapshot",
"files",
"to",
"be",
"deleted",
"}",
"}",
"}"
] |
[
"returns",
"the",
"number",
"of",
"settings",
"in",
"this",
"settings",
"object"
] | [
"public",
"int",
"size",
"(",
")",
"{",
"return",
"key",
"set",
"(",
")",
"size",
"(",
")",
";",
"}"
] |
[
"auto",
"generate",
"worker",
"id",
",",
"try",
"using",
"mac",
"first",
",",
"if",
"failed",
",",
"then",
"randomly",
"generate",
"one"
] | [
"private",
"long",
"generate",
"worker",
"id",
"(",
")",
"{",
"try",
"{",
"return",
"generate",
"worker",
"id",
"base",
"on",
"mac",
"(",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"return",
"generate",
"random",
"worker",
"id",
"(",
")",
";",
"}",
"}"
] |
[
"when",
"some",
"fields",
"are",
"added",
"into",
"the",
"class",
"after",
"last",
"upgrade",
",",
"the",
"table",
"should",
"synchronize",
"the",
"changes",
"by",
"adding",
"the",
"corresponding",
"columns"
] | [
"private",
"void",
"add",
"columns",
"(",
"list",
"<",
"column",
"model",
">",
"column",
"model",
"list",
")",
"{",
"lite",
"pal",
"log",
"d",
"(",
"tag",
",",
"\"",
"do",
"add",
"column",
"\"",
")",
";",
"execute",
"(",
"get",
"add",
"column",
"s",
"q",
"ls",
"(",
"column",
"model",
"list",
")",
",",
"m",
"db",
")",
";",
"for",
"(",
"column",
"model",
"column",
"model",
":",
"column",
"model",
"list",
")",
"{",
"m",
"table",
"model",
"d",
"b",
"add",
"column",
"model",
"(",
"column",
"model",
")",
";",
"}",
"}"
] |
[
"visits",
"the",
"given",
"deprecated",
"attribute",
"of",
"any",
"type",
"of",
"class",
"member"
] | [
"public",
"void",
"visit",
"deprecated",
"attribute",
"(",
"clazz",
"clazz",
",",
"member",
"member",
",",
"deprecated",
"attribute",
"deprecated",
"attribute",
")",
"{",
"visit",
"deprecated",
"attribute",
"(",
"clazz",
",",
"deprecated",
"attribute",
")",
";",
"}"
] |
[
"allows",
"the",
"core",
"to",
"calibrate",
"itself"
] | [
"public",
"void",
"calibrate",
"(",
"resource",
"calculator",
"plugin",
"monitor",
",",
"long",
"total",
"cpu",
"usage",
")",
";"
] |
[
"create",
"the",
"ticket",
"object"
] | [
"<",
"t",
"extends",
"proxy",
"granting",
"ticket",
">",
"t",
"create",
"(",
"service",
"ticket",
"ticket",
",",
"authentication",
"authentication",
",",
"class",
"<",
"t",
">",
"clazz",
")",
"throws",
"abstract",
"ticket",
"exception",
";"
] |
[
"the",
"list",
"of",
"ignored",
"unassigned",
"shards",
"(",
"read",
"only",
")",
"the",
"ignored",
"unassigned",
"shards",
"are",
"not",
"part",
"of",
"the",
"formal",
"unassigned",
"list",
",",
"but",
"are",
"kept",
"around",
"and",
"used",
"to",
"build",
"back",
"the",
"list",
"of",
"unassigned",
"shards",
"as",
"part",
"of",
"the",
"routing",
"table"
] | [
"public",
"list",
"<",
"shard",
"routing",
">",
"ignored",
"(",
")",
"{",
"return",
"collections",
"unmodifiable",
"list",
"(",
"ignored",
")",
";",
"}"
] |
[
"get",
"the",
"executor",
"used",
"to",
"notify",
"listeners",
"when",
"this",
"promise",
"is",
"complete",
"it",
"is",
"assumed",
"this",
"executor",
"will",
"protect",
"against",
"{",
"@",
"link",
"stack",
"overflow",
"error",
"}",
"exceptions",
"the",
"executor",
"may",
"be",
"used",
"to",
"avoid",
"{",
"@",
"link",
"stack",
"overflow",
"error",
"}",
"by",
"executing",
"a",
"{",
"@",
"link",
"runnable",
"}",
"if",
"the",
"stack",
"depth",
"exceeds",
"a",
"threshold"
] | [
"protected",
"event",
"executor",
"executor",
"(",
")",
"{",
"return",
"executor",
";",
"}"
] |
[
"returns",
"true",
"if",
"{",
"@",
"code",
"network",
"}",
"has",
"at",
"least",
"one",
"cycle",
"a",
"cycle",
"is",
"defined",
"as",
"a",
"non",
"-",
"empty",
"subset",
"of",
"edges",
"in",
"a",
"graph",
"arranged",
"to",
"form",
"a",
"path",
"(",
"a",
"sequence",
"of",
"adjacent",
"outgoing",
"edges",
")",
"starting",
"and",
"ending",
"with",
"the",
"same",
"node",
"this",
"method",
"will",
"detect",
"any",
"non",
"-",
"empty",
"cycle",
",",
"including",
"self",
"-",
"loops",
"(",
"a",
"cycle",
"of",
"length",
"1",
")"
] | [
"public",
"static",
"boolean",
"has",
"cycle",
"(",
"network",
"<",
"?",
",",
"?",
">",
"network",
")",
"{",
"/",
"/",
"in",
"a",
"directed",
"graph",
",",
"parallel",
"edges",
"cannot",
"introduce",
"a",
"cycle",
"in",
"an",
"acyclic",
"graph",
"/",
"/",
"however",
",",
"in",
"an",
"undirected",
"graph",
",",
"any",
"parallel",
"edge",
"induces",
"a",
"cycle",
"in",
"the",
"graph",
"if",
"(",
"!",
"network",
"is",
"directed",
"(",
")",
"&",
"&",
"network",
"allows",
"parallel",
"edges",
"(",
")",
"&",
"&",
"network",
"edges",
"(",
")",
"size",
"(",
")",
">",
"network",
"as",
"graph",
"(",
")",
"edges",
"(",
")",
"size",
"(",
")",
")",
"{",
"return",
"true",
";",
"}",
"return",
"has",
"cycle",
"(",
"network",
"as",
"graph",
"(",
")",
")",
";",
"}"
] |
[
"patch",
"another",
"-",
"fakedummy",
":",
"to",
"test",
"special",
"tags",
"to",
"test",
"special",
"tags",
"and",
"operation",
"id",
"starting",
"with",
"number"
] | [
"default",
"response",
"entity",
"<",
"client",
">",
"call",
"1",
"2",
"3test",
"special",
"tags",
"(",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"client",
"model",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"body",
"client",
"body",
")",
"{",
"get",
"request",
"(",
")",
"if",
"present",
"(",
"request",
"-",
">",
"{",
"for",
"(",
"media",
"type",
"media",
"type",
":",
"media",
"type",
"parse",
"media",
"types",
"(",
"request",
"get",
"header",
"(",
"\"",
"accept",
"\"",
")",
")",
")",
"{",
"if",
"(",
"media",
"type",
"is",
"compatible",
"with",
"(",
"media",
"type",
"value",
"of",
"(",
"\"",
"application",
"/",
"json",
"\"",
")",
")",
")",
"{",
"string",
"example",
"string",
"=",
"\"",
"{",
"\\",
"\"",
"client",
"\\",
"\"",
":",
"\\",
"\"",
"client",
"\\",
"\"",
"}",
"\"",
";",
"api",
"util",
"set",
"example",
"response",
"(",
"request",
",",
"\"",
"application",
"/",
"json",
"\"",
",",
"example",
"string",
")",
";",
"break",
";",
"}",
"}",
"}",
")",
";",
"return",
"new",
"response",
"entity",
"<",
">",
"(",
"http",
"status",
"not",
"implemented",
")",
";",
"}"
] |
[
"set",
"the",
"list",
"of",
"advice",
"advisor",
"bean",
"names",
"this",
"must",
"always",
"be",
"set",
"to",
"use",
"this",
"factory",
"bean",
"in",
"a",
"bean",
"factory",
"the",
"referenced",
"beans",
"should",
"be",
"of",
"type",
"interceptor",
",",
"advisor",
"or",
"advice",
"the",
"last",
"entry",
"in",
"the",
"list",
"can",
"be",
"the",
"name",
"of",
"any",
"bean",
"in",
"the",
"factory",
"if",
"it",
"'",
"s",
"neither",
"an",
"advice",
"nor",
"an",
"advisor",
",",
"a",
"new",
"singleton",
"target",
"source",
"is",
"added",
"to",
"wrap",
"it",
"such",
"a",
"target",
"bean",
"cannot",
"be",
"used",
"if",
"the",
"\"",
"target",
"\"",
"or",
"\"",
"target",
"source",
"\"",
"or",
"\"",
"target",
"name",
"\"",
"property",
"is",
"set",
",",
"in",
"which",
"case",
"the",
"\"",
"interceptor",
"names",
"\"",
"array",
"must",
"contain",
"only",
"advice",
"advisor",
"bean",
"names",
"<",
"b",
">",
"note",
":",
"specifying",
"a",
"target",
"bean",
"as",
"final",
"name",
"in",
"the",
"\"",
"interceptor",
"names",
"\"",
"list",
"is",
"deprecated",
"and",
"will",
"be",
"removed",
"in",
"a",
"future",
"spring",
"version",
"<",
"b",
">",
"use",
"the",
"{",
"@",
"link",
"#",
"set",
"target",
"name",
"\"",
"target",
"name",
"\"",
"}",
"property",
"instead"
] | [
"public",
"void",
"set",
"interceptor",
"names",
"(",
"string",
"interceptor",
"names",
")",
"{",
"this",
"interceptor",
"names",
"=",
"interceptor",
"names",
";",
"}"
] |
[
"gets",
"the",
"key",
"type"
] | [
"public",
"final",
"type",
"literal",
"<",
"t",
">",
"get",
"type",
"literal",
"(",
")",
"{",
"return",
"type",
"literal",
";",
"}"
] |
[
"find",
"the",
"beginning",
"of",
"the",
"next",
"instruction",
"range"
] | [
"protected",
"address",
"get",
"next",
"address",
"(",
"task",
"monitor",
"monitor",
",",
"program",
"program",
",",
"address",
"address",
")",
"throws",
"cancelled",
"exception",
"{",
"function",
"function",
"=",
"program",
"get",
"listing",
"(",
")",
"get",
"function",
"containing",
"(",
"address",
")",
";",
"if",
"(",
"function",
"=",
"=",
"null",
")",
"{",
"function",
"=",
"get",
"next",
"function",
"(",
"program",
",",
"address",
",",
"true",
")",
";",
"}",
"if",
"(",
"function",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"return",
"find",
"next",
"instruction",
"address",
"not",
"in",
"function",
"(",
"monitor",
",",
"program",
",",
"function",
"get",
"entry",
"point",
"(",
")",
",",
"true",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"id",
"'"
] | [
"public",
"void",
"id",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"id",
"}"
] |
[
"test",
"the",
"property",
"'",
"integer",
"item",
"'"
] | [
"public",
"void",
"integer",
"item",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"integer",
"item",
"}"
] |
[
"returns",
"the",
"file",
"this",
"location",
"is",
"from"
] | [
"public",
"final",
"file",
"file",
"(",
")",
"{",
"return",
"home",
";",
"}"
] |
[
"any",
"comments",
"associated",
"with",
"the",
"declaration",
"<",
"code",
">",
"optional",
"string",
"comment",
"=",
"2",
";",
"<",
"code",
">"
] | [
"public",
"java",
"lang",
"string",
"get",
"comment",
"(",
")",
"{",
"return",
"instance",
"get",
"comment",
"(",
")",
";",
"}"
] |
[
"given",
"a",
"character",
"position",
"from",
"0",
"to",
"data",
"unit",
"symbol",
"size",
"-",
"1",
"it",
"returns",
"a",
"number",
"from",
"0",
"to",
"unit",
"byte",
"size",
"-",
"1",
"indicating",
"which",
"byte",
"the",
"character",
"position",
"was",
"obtained",
"from"
] | [
"public",
"int",
"get",
"byte",
"offset",
"(",
"byte",
"block",
"block",
",",
"int",
"position",
")",
"{",
"return",
"0",
";",
"}"
] |
[
"returns",
"the",
"difference",
"of",
"this",
"long",
"value",
"and",
"the",
"given",
"long",
"value"
] | [
"public",
"long",
"value",
"subtract",
"(",
"long",
"value",
"other",
")",
"{",
"return",
"other",
"subtract",
"from",
"(",
"this",
")",
";",
"}"
] |
[
"remove",
"all",
"predecessors",
"edges",
"and",
"return",
"collection",
"of",
"its",
"self",
"edge",
"removed",
"but",
"did",
"not",
"returned",
"in",
"result",
"collection"
] | [
"collection",
"<",
"node",
"<",
"t",
">",
">",
"remove",
"all",
"predecessors",
"(",
")",
"{",
"this",
"remove",
"edge",
"(",
"this",
")",
";",
"/",
"/",
"remove",
"self",
"edge",
"collection",
"<",
"node",
"<",
"t",
">",
">",
"predecessors",
"=",
"this",
"preds",
"clear",
"(",
")",
";",
"for",
"(",
"node",
"<",
"t",
">",
"p",
":",
"predecessors",
")",
"{",
"if",
"(",
"!",
"p",
"remove",
"successor",
"(",
"this",
")",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"inconsistent",
"graph",
"state",
"\"",
")",
";",
"}",
"}",
"return",
"predecessors",
";",
"}"
] |
[
"disable",
"the",
"renderer",
",",
"transitioning",
"it",
"to",
"the",
"{",
"@",
"link",
"#",
"state",
"disabled",
"}",
"state",
"this",
"method",
"may",
"be",
"called",
"when",
"the",
"renderer",
"is",
"in",
"the",
"following",
"states",
":",
"{",
"@",
"link",
"#",
"state",
"enabled",
"}"
] | [
"void",
"disable",
"(",
")",
";"
] |
[
"joins",
"this",
"{",
"@",
"link",
"table",
"}",
"with",
"an",
"user",
"-",
"defined",
"{",
"@",
"link",
"table",
"function",
"}",
"this",
"join",
"is",
"similar",
"to",
"a",
"sql",
"left",
"outer",
"join",
"with",
"on",
"true",
"predicate",
"but",
"works",
"with",
"a",
"table",
"function",
"each",
"row",
"of",
"the",
"table",
"is",
"joined",
"with",
"all",
"rows",
"produced",
"by",
"the",
"table",
"function",
"if",
"the",
"table",
"function",
"does",
"not",
"produce",
"any",
"row",
",",
"the",
"outer",
"row",
"is",
"padded",
"with",
"nulls",
"example",
":",
"{",
"@",
"code",
"class",
"my",
"split",
"u",
"d",
"t",
"f",
"extends",
"table",
"function",
"<",
"string",
">",
"{",
"public",
"void",
"eval",
"(",
"string",
"str",
")",
"{",
"str",
"split",
"(",
"\"",
"#",
"\"",
")",
"for",
"each",
"(",
"this",
":",
":",
"collect",
")",
";",
"}",
"}",
"table",
"left",
"outer",
"join",
"lateral",
"(",
"call",
"(",
"my",
"split",
"u",
"d",
"t",
"f",
"class",
",",
"$",
"(",
"\"",
"c",
"\"",
")",
")",
"as",
"(",
"\"",
"s",
"\"",
")",
",",
"$",
"(",
"\"",
"a",
"\"",
")",
"is",
"equal",
"(",
"$",
"(",
"\"",
"s",
"\"",
")",
")",
")",
"select",
"(",
"$",
"(",
"\"",
"a",
"\"",
")",
",",
"$",
"(",
"\"",
"b",
"\"",
")",
",",
"$",
"(",
"\"",
"c",
"\"",
")",
",",
"$",
"(",
"\"",
"s",
"\"",
")",
")",
";",
"}",
"scala",
"example",
":",
"{",
"@",
"code",
"class",
"my",
"split",
"u",
"d",
"t",
"f",
"extends",
"table",
"function",
"[",
"string",
"]",
"{",
"def",
"eval",
"(",
"str",
":",
"string",
")",
":",
"unit",
"=",
"{",
"str",
"split",
"(",
"\"",
"#",
"\"",
")",
"foreach",
"(",
"collect",
")",
"}",
"}",
"val",
"split",
"=",
"new",
"my",
"split",
"u",
"d",
"t",
"f",
"(",
")",
"table",
"left",
"outer",
"join",
"lateral",
"(",
"split",
"(",
"$",
"\"",
"c",
"\"",
")",
"as",
"\"",
"s",
"\"",
",",
"$",
"\"",
"a",
"\"",
"=",
"=",
"=",
"$",
"\"",
"s",
"\"",
")",
"select",
"(",
"$",
"\"",
"a",
"\"",
",",
"$",
"\"",
"b",
"\"",
",",
"$",
"\"",
"c",
"\"",
",",
"$",
"\"",
"s",
"\"",
")",
"}"
] | [
"table",
"left",
"outer",
"join",
"lateral",
"(",
"expression",
"table",
"function",
"call",
",",
"expression",
"join",
"predicate",
")",
";"
] |
[
"returns",
"the",
"extension",
"filter",
"for",
"{",
"@",
"link",
"web",
"socket",
"extension",
"decoder",
"}",
"decoder"
] | [
"web",
"socket",
"extension",
"filter",
"decoder",
"filter",
"(",
")",
";"
] |
[
"parse",
"the",
"given",
"value",
"into",
"a",
"days",
"of",
"week",
"{",
"@",
"code",
"cron",
"field",
"}",
",",
"the",
"sixth",
"entry",
"of",
"a",
"cron",
"expression"
] | [
"public",
"static",
"cron",
"field",
"parse",
"days",
"of",
"week",
"(",
"string",
"value",
")",
"{",
"value",
"=",
"replace",
"ordinals",
"(",
"value",
",",
"days",
")",
";",
"if",
"(",
"!",
"quartz",
"cron",
"field",
"is",
"quartz",
"days",
"of",
"week",
"field",
"(",
"value",
")",
")",
"{",
"return",
"bits",
"cron",
"field",
"parse",
"days",
"of",
"week",
"(",
"value",
")",
";",
"}",
"else",
"{",
"return",
"parse",
"list",
"(",
"value",
",",
"type",
"day",
"of",
"week",
",",
"(",
"field",
",",
"type",
")",
"-",
">",
"{",
"if",
"(",
"quartz",
"cron",
"field",
"is",
"quartz",
"days",
"of",
"week",
"field",
"(",
"field",
")",
")",
"{",
"return",
"quartz",
"cron",
"field",
"parse",
"days",
"of",
"week",
"(",
"field",
")",
";",
"}",
"else",
"{",
"return",
"bits",
"cron",
"field",
"parse",
"days",
"of",
"week",
"(",
"field",
")",
";",
"}",
"}",
")",
";",
"}",
"}"
] |
[
"gets",
"the",
"addresses",
"resolved",
"by",
"name",
"resolution"
] | [
"public",
"list",
"<",
"equivalent",
"address",
"group",
">",
"get",
"addresses",
"(",
")",
"{",
"return",
"addresses",
";",
"}"
] |
[
"sets",
"the",
"cache",
"for",
"{",
"@",
"code",
"cname",
"}",
"mappings"
] | [
"public",
"dns",
"name",
"resolver",
"builder",
"cname",
"cache",
"(",
"dns",
"cname",
"cache",
"cname",
"cache",
")",
"{",
"this",
"cname",
"cache",
"=",
"cname",
"cache",
";",
"return",
"this",
";",
"}"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"model",
"tests",
"for",
"client"
] | [
"public",
"void",
"test",
"client",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"client",
"}"
] |
[
"sets",
"the",
"delay",
"of",
"a",
"sniff",
"execution",
"scheduled",
"after",
"a",
"failure",
"(",
"in",
"milliseconds",
")"
] | [
"public",
"sniffer",
"builder",
"set",
"sniff",
"after",
"failure",
"delay",
"millis",
"(",
"int",
"sniff",
"after",
"failure",
"delay",
"millis",
")",
"{",
"if",
"(",
"sniff",
"after",
"failure",
"delay",
"millis",
"<",
"=",
"0",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"sniff",
"after",
"failure",
"delay",
"millis",
"must",
"be",
"greater",
"than",
"0",
"\"",
")",
";",
"}",
"this",
"sniff",
"after",
"failure",
"delay",
"millis",
"=",
"sniff",
"after",
"failure",
"delay",
"millis",
";",
"return",
"this",
";",
"}"
] |
[
"issues",
"a",
"read",
"request",
",",
"which",
"will",
"asynchronously",
"fill",
"the",
"given",
"segment",
"with",
"the",
"next",
"block",
"in",
"the",
"underlying",
"file",
"channel",
"once",
"the",
"read",
"request",
"is",
"fulfilled",
",",
"the",
"segment",
"will",
"be",
"added",
"to",
"this",
"reader",
"'",
"s",
"return",
"queue"
] | [
"public",
"void",
"read",
"block",
"(",
"memory",
"segment",
"segment",
")",
"throws",
"i",
"o",
"exception",
"{",
"add",
"request",
"(",
"new",
"segment",
"read",
"request",
"(",
"this",
",",
"segment",
")",
")",
";",
"}"
] |
[
"remove",
"cluster",
"flow",
"rule",
"property",
"for",
"a",
"specific",
"namespace"
] | [
"public",
"static",
"void",
"remove",
"property",
"(",
"string",
"namespace",
")",
"{",
"assert",
"util",
"not",
"empty",
"(",
"namespace",
",",
"\"",
"namespace",
"cannot",
"be",
"empty",
"\"",
")",
";",
"synchronized",
"(",
"update",
"lock",
")",
"{",
"namespace",
"flow",
"property",
"<",
"flow",
"rule",
">",
"property",
"=",
"property",
"map",
"get",
"(",
"namespace",
")",
";",
"if",
"(",
"property",
"!",
"=",
"null",
")",
"{",
"property",
"get",
"property",
"(",
")",
"remove",
"listener",
"(",
"property",
"get",
"listener",
"(",
")",
")",
";",
"property",
"map",
"remove",
"(",
"namespace",
")",
";",
"}",
"record",
"log",
"info",
"(",
"\"",
"[",
"cluster",
"flow",
"rule",
"manager",
"]",
"removing",
"property",
"from",
"cluster",
"flow",
"rule",
"manager",
"\"",
"+",
"\"",
"for",
"namespace",
"<",
"{",
"}",
">",
"\"",
",",
"namespace",
")",
";",
"}",
"}"
] |
[
"turn",
"speculative",
"execution",
"on",
"or",
"off",
"for",
"this",
"job"
] | [
"public",
"void",
"set",
"speculative",
"execution",
"(",
"boolean",
"speculative",
"execution",
")",
"{",
"set",
"map",
"speculative",
"execution",
"(",
"speculative",
"execution",
")",
";",
"set",
"reduce",
"speculative",
"execution",
"(",
"speculative",
"execution",
")",
";",
"}"
] |
[
"creates",
"a",
"heartbeat",
"manager",
"which",
"does",
"not",
"actively",
"send",
"heartbeats"
] | [
"public",
"<",
"i",
",",
"o",
">",
"heartbeat",
"manager",
"<",
"i",
",",
"o",
">",
"create",
"heartbeat",
"manager",
"(",
"resource",
"i",
"d",
"resource",
"id",
",",
"heartbeat",
"listener",
"<",
"i",
",",
"o",
">",
"heartbeat",
"listener",
",",
"scheduled",
"executor",
"main",
"thread",
"executor",
",",
"logger",
"log",
")",
"{",
"return",
"new",
"heartbeat",
"manager",
"impl",
"<",
">",
"(",
"heartbeat",
"timeout",
",",
"resource",
"id",
",",
"heartbeat",
"listener",
",",
"main",
"thread",
"executor",
",",
"log",
")",
";",
"}"
] |
[
"parses",
"a",
"$",
"path",
"value",
"into",
"a",
"list",
"of",
"paths",
"a",
"null",
"search",
"path",
"is",
"treated",
"as",
"an",
"empty",
"one",
"relative",
"entries",
"in",
"$",
"path",
"are",
"ignored"
] | [
"public",
"static",
"list",
"<",
"path",
">",
"parse",
"(",
"file",
"system",
"fs",
",",
"@",
"nullable",
"string",
"search",
"path",
")",
"{",
"list",
"<",
"path",
">",
"paths",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"if",
"(",
"search",
"path",
"=",
"=",
"null",
")",
"{",
"return",
"paths",
";",
"}",
"for",
"(",
"string",
"p",
":",
"separator",
"split",
"(",
"search",
"path",
")",
")",
"{",
"path",
"fragment",
"pf",
"=",
"path",
"fragment",
"create",
"(",
"p",
")",
";",
"if",
"(",
"pf",
"is",
"absolute",
"(",
")",
")",
"{",
"paths",
"add",
"(",
"fs",
"get",
"path",
"(",
"pf",
")",
")",
";",
"}",
"}",
"return",
"paths",
";",
"}"
] |
[
"whether",
"the",
"x",
"attrs",
"returned",
"by",
"getx",
"attrs",
"(",
")",
"were",
"removed",
"(",
"as",
"opposed",
"to",
"added",
")"
] | [
"public",
"boolean",
"isx",
"attrs",
"removed",
"(",
")",
"{",
"return",
"x",
"attrs",
"removed",
";",
"}"
] |
[
"response",
"when",
"running",
"with",
"leading",
"job",
"manager"
] | [
"private",
"void",
"respond",
"to",
"request",
"(",
"channel",
"handler",
"context",
"ctx",
",",
"http",
"request",
"request",
",",
"string",
"request",
"path",
")",
"throws",
"i",
"o",
"exception",
",",
"parse",
"exception",
",",
"u",
"r",
"i",
"syntax",
"exception",
",",
"rest",
"handler",
"exception",
"{",
"/",
"/",
"convert",
"to",
"absolute",
"path",
"final",
"file",
"file",
"=",
"new",
"file",
"(",
"root",
"path",
",",
"request",
"path",
")",
";",
"if",
"(",
"!",
"file",
"exists",
"(",
")",
")",
"{",
"/",
"/",
"file",
"does",
"not",
"exist",
"try",
"to",
"load",
"it",
"with",
"the",
"classloader",
"class",
"loader",
"cl",
"=",
"static",
"file",
"server",
"handler",
"class",
"get",
"class",
"loader",
"(",
")",
";",
"try",
"(",
"input",
"stream",
"resource",
"stream",
"=",
"cl",
"get",
"resource",
"as",
"stream",
"(",
"\"",
"web",
"\"",
"+",
"request",
"path",
")",
")",
"{",
"boolean",
"success",
"=",
"false",
";",
"try",
"{",
"if",
"(",
"resource",
"stream",
"!",
"=",
"null",
")",
"{",
"url",
"root",
"=",
"cl",
"get",
"resource",
"(",
"\"",
"web",
"\"",
")",
";",
"url",
"requested",
"=",
"cl",
"get",
"resource",
"(",
"\"",
"web",
"\"",
"+",
"request",
"path",
")",
";",
"if",
"(",
"root",
"!",
"=",
"null",
"&",
"&",
"requested",
"!",
"=",
"null",
")",
"{",
"uri",
"root",
"u",
"r",
"i",
"=",
"new",
"uri",
"(",
"root",
"get",
"path",
"(",
")",
")",
"normalize",
"(",
")",
";",
"uri",
"requested",
"u",
"r",
"i",
"=",
"new",
"uri",
"(",
"requested",
"get",
"path",
"(",
")",
")",
"normalize",
"(",
")",
";",
"/",
"/",
"check",
"that",
"we",
"don",
"'",
"t",
"load",
"anything",
"from",
"outside",
"of",
"the",
"/",
"/",
"expected",
"scope",
"if",
"(",
"!",
"root",
"u",
"r",
"i",
"relativize",
"(",
"requested",
"u",
"r",
"i",
")",
"equals",
"(",
"requested",
"u",
"r",
"i",
")",
")",
"{",
"logger",
"debug",
"(",
"\"",
"loading",
"missing",
"file",
"from",
"classloader",
":",
"{",
"}",
"\"",
",",
"request",
"path",
")",
";",
"/",
"/",
"ensure",
"that",
"directory",
"to",
"file",
"exists",
"file",
"get",
"parent",
"file",
"(",
")",
"mkdirs",
"(",
")",
";",
"files",
"copy",
"(",
"resource",
"stream",
",",
"file",
"to",
"path",
"(",
")",
")",
";",
"success",
"=",
"true",
";",
"}",
"}",
"}",
"}",
"catch",
"(",
"throwable",
"t",
")",
"{",
"logger",
"error",
"(",
"\"",
"error",
"while",
"responding",
"\"",
",",
"t",
")",
";",
"}",
"finally",
"{",
"if",
"(",
"!",
"success",
")",
"{",
"logger",
"debug",
"(",
"\"",
"unable",
"to",
"load",
"requested",
"file",
"{",
"}",
"from",
"classloader",
"\"",
",",
"request",
"path",
")",
";",
"throw",
"new",
"not",
"found",
"exception",
"(",
"string",
"format",
"(",
"\"",
"unable",
"to",
"load",
"requested",
"file",
"%",
"s",
"\"",
",",
"request",
"path",
")",
")",
";",
"}",
"}",
"}",
"}",
"check",
"file",
"validity",
"(",
"file",
",",
"root",
"path",
",",
"logger",
")",
";",
"/",
"/",
"cache",
"validation",
"final",
"string",
"if",
"modified",
"since",
"=",
"request",
"headers",
"(",
")",
"get",
"(",
"if",
"modified",
"since",
")",
";",
"if",
"(",
"if",
"modified",
"since",
"!",
"=",
"null",
"&",
"&",
"!",
"if",
"modified",
"since",
"is",
"empty",
"(",
")",
")",
"{",
"simple",
"date",
"format",
"date",
"formatter",
"=",
"new",
"simple",
"date",
"format",
"(",
"http",
"date",
"format",
",",
"locale",
"us",
")",
";",
"date",
"if",
"modified",
"since",
"date",
"=",
"date",
"formatter",
"parse",
"(",
"if",
"modified",
"since",
")",
";",
"/",
"/",
"only",
"compare",
"up",
"to",
"the",
"second",
"because",
"the",
"datetime",
"format",
"we",
"send",
"to",
"the",
"client",
"/",
"/",
"does",
"not",
"have",
"milliseconds",
"long",
"if",
"modified",
"since",
"date",
"seconds",
"=",
"if",
"modified",
"since",
"date",
"get",
"time",
"(",
")",
"/",
"1000",
";",
"long",
"file",
"last",
"modified",
"seconds",
"=",
"file",
"last",
"modified",
"(",
")",
"/",
"1000",
";",
"if",
"(",
"if",
"modified",
"since",
"date",
"seconds",
"=",
"=",
"file",
"last",
"modified",
"seconds",
")",
"{",
"if",
"(",
"logger",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"logger",
"debug",
"(",
"\"",
"responding",
"'",
"not",
"modified",
"'",
"for",
"file",
"'",
"\"",
"+",
"file",
"get",
"absolute",
"path",
"(",
")",
"+",
"'",
"\\",
"'",
"'",
")",
";",
"}",
"send",
"not",
"modified",
"(",
"ctx",
")",
";",
"return",
";",
"}",
"}",
"if",
"(",
"logger",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"logger",
"debug",
"(",
"\"",
"responding",
"with",
"file",
"'",
"\"",
"+",
"file",
"get",
"absolute",
"path",
"(",
")",
"+",
"'",
"\\",
"'",
"'",
")",
";",
"}",
"/",
"/",
"don",
"'",
"t",
"need",
"to",
"close",
"this",
"manually",
"netty",
"'",
"s",
"default",
"file",
"region",
"will",
"take",
"care",
"of",
"it",
"final",
"random",
"access",
"file",
"raf",
";",
"try",
"{",
"raf",
"=",
"new",
"random",
"access",
"file",
"(",
"file",
",",
"\"",
"r",
"\"",
")",
";",
"}",
"catch",
"(",
"file",
"not",
"found",
"exception",
"e",
")",
"{",
"if",
"(",
"logger",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"logger",
"debug",
"(",
"\"",
"could",
"not",
"find",
"file",
"{",
"}",
"\"",
",",
"file",
"get",
"absolute",
"path",
"(",
")",
")",
";",
"}",
"throw",
"new",
"not",
"found",
"exception",
"(",
"\"",
"file",
"not",
"found",
"\"",
")",
";",
"}",
"try",
"{",
"long",
"file",
"length",
"=",
"raf",
"length",
"(",
")",
";",
"http",
"response",
"response",
"=",
"new",
"default",
"http",
"response",
"(",
"http",
"1",
"1",
",",
"ok",
")",
";",
"set",
"content",
"type",
"header",
"(",
"response",
",",
"file",
")",
";",
"set",
"date",
"and",
"cache",
"headers",
"(",
"response",
",",
"file",
")",
";",
"if",
"(",
"http",
"headers",
"is",
"keep",
"alive",
"(",
"request",
")",
")",
"{",
"response",
"headers",
"(",
")",
"set",
"(",
"connection",
",",
"http",
"headers",
"values",
"keep",
"alive",
")",
";",
"}",
"http",
"headers",
"set",
"content",
"length",
"(",
"response",
",",
"file",
"length",
")",
";",
"/",
"/",
"write",
"the",
"initial",
"line",
"and",
"the",
"header",
"ctx",
"write",
"(",
"response",
")",
";",
"/",
"/",
"write",
"the",
"content",
"channel",
"future",
"last",
"content",
"future",
";",
"if",
"(",
"ctx",
"pipeline",
"(",
")",
"get",
"(",
"ssl",
"handler",
"class",
")",
"=",
"=",
"null",
")",
"{",
"ctx",
"write",
"(",
"new",
"default",
"file",
"region",
"(",
"raf",
"get",
"channel",
"(",
")",
",",
"0",
",",
"file",
"length",
")",
",",
"ctx",
"new",
"progressive",
"promise",
"(",
")",
")",
";",
"last",
"content",
"future",
"=",
"ctx",
"write",
"and",
"flush",
"(",
"last",
"http",
"content",
"empty",
"last",
"content",
")",
";",
"}",
"else",
"{",
"last",
"content",
"future",
"=",
"ctx",
"write",
"and",
"flush",
"(",
"new",
"http",
"chunked",
"input",
"(",
"new",
"chunked",
"file",
"(",
"raf",
",",
"0",
",",
"file",
"length",
",",
"8192",
")",
")",
",",
"ctx",
"new",
"progressive",
"promise",
"(",
")",
")",
";",
"/",
"/",
"http",
"chunked",
"input",
"will",
"write",
"the",
"end",
"marker",
"(",
"last",
"http",
"content",
")",
"for",
"us",
"}",
"/",
"/",
"close",
"the",
"connection",
",",
"if",
"no",
"keep",
"-",
"alive",
"is",
"needed",
"if",
"(",
"!",
"http",
"headers",
"is",
"keep",
"alive",
"(",
"request",
")",
")",
"{",
"last",
"content",
"future",
"add",
"listener",
"(",
"channel",
"future",
"listener",
"close",
")",
";",
"}",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"raf",
"close",
"(",
")",
";",
"logger",
"error",
"(",
"\"",
"failed",
"to",
"serve",
"file",
"\"",
",",
"e",
")",
";",
"throw",
"new",
"rest",
"handler",
"exception",
"(",
"\"",
"internal",
"server",
"error",
"\"",
",",
"internal",
"server",
"error",
")",
";",
"}",
"}"
] |
[
"remove",
"the",
"next",
"expired",
"set",
"of",
"elements",
"from",
"expire",
"map",
"this",
"method",
"needs",
"to",
"be",
"called",
"frequently",
"enough",
"by",
"checking",
"get",
"wait",
"time",
"(",
")",
",",
"otherwise",
"there",
"will",
"be",
"a",
"backlog",
"of",
"empty",
"sets",
"queued",
"up",
"in",
"expiry",
"map"
] | [
"public",
"set",
"<",
"e",
">",
"poll",
"(",
")",
"{",
"long",
"now",
"=",
"time",
"current",
"elapsed",
"time",
"(",
")",
";",
"long",
"expiration",
"time",
"=",
"next",
"expiration",
"time",
"get",
"(",
")",
";",
"if",
"(",
"now",
"<",
"expiration",
"time",
")",
"{",
"return",
"collections",
"empty",
"set",
"(",
")",
";",
"}",
"set",
"<",
"e",
">",
"set",
"=",
"null",
";",
"long",
"new",
"expiration",
"time",
"=",
"expiration",
"time",
"+",
"expiration",
"interval",
";",
"if",
"(",
"next",
"expiration",
"time",
"compare",
"and",
"set",
"(",
"expiration",
"time",
",",
"new",
"expiration",
"time",
")",
")",
"{",
"set",
"=",
"expiry",
"map",
"remove",
"(",
"expiration",
"time",
")",
";",
"}",
"if",
"(",
"set",
"=",
"=",
"null",
")",
"{",
"return",
"collections",
"empty",
"set",
"(",
")",
";",
"}",
"return",
"set",
";",
"}"
] |
[
"return",
"the",
"embedded",
"object",
"(",
"essentially",
"what",
"could",
"stand",
"on",
"its",
"own",
"as",
"a",
"mangled",
"symbol",
")",
"that",
"is",
"used",
"as",
"part",
"of",
"the",
"name",
"of",
"mangled",
"object"
] | [
"public",
"m",
"d",
"object",
"c",
"p",
"p",
"get",
"embedded",
"object",
"(",
")",
"{",
"return",
"embedded",
"object",
";",
"}"
] |
[
"deserialize",
"the",
"body",
"of",
"the",
"{",
"@",
"link",
"abstract",
"symbol",
"information",
"}",
"according",
"to",
"the",
"gsi",
"7",
"00",
"specification"
] | [
"private",
"void",
"deserialize",
"gsi",
"7",
"0",
"hash",
"table",
"(",
"pdb",
"byte",
"reader",
"reader",
",",
"task",
"monitor",
"monitor",
")",
"throws",
"pdb",
"exception",
",",
"cancelled",
"exception",
"{",
"if",
"(",
"reader",
"num",
"remaining",
"(",
")",
"!",
"=",
"hash",
"records",
"length",
"+",
"buckets",
"length",
")",
"{",
"throw",
"new",
"pdb",
"exception",
"(",
"\"",
"data",
"count",
"mismatch",
"in",
"gsi",
"stream",
"\"",
")",
";",
"}",
"if",
"(",
"hash",
"records",
"length",
"=",
"=",
"0",
"|",
"|",
"buckets",
"length",
"=",
"=",
"0",
")",
"{",
"return",
";",
"}",
"pdb",
"byte",
"reader",
"hash",
"records",
"reader",
"=",
"reader",
"get",
"sub",
"pdb",
"byte",
"reader",
"(",
"hash",
"records",
"length",
")",
";",
"pdb",
"byte",
"reader",
"buckets",
"reader",
"=",
"reader",
"get",
"sub",
"pdb",
"byte",
"reader",
"(",
"buckets",
"length",
")",
";",
"deserialized",
"compressed",
"hash",
"buckets",
"(",
"buckets",
"reader",
",",
"monitor",
")",
";",
"/",
"/",
"int",
"i",
"=",
"0",
";",
"/",
"/",
"for",
"(",
"int",
"x",
":",
"hash",
"bucket",
"offsets",
")",
"{",
"/",
"/",
"system",
"out",
"println",
"(",
"string",
"format",
"(",
"\"",
"0x",
"%",
"0",
"4x",
":",
"0x",
"%",
"0",
"8x",
"\"",
",",
"i",
"+",
"+",
",",
"x",
")",
")",
";",
"/",
"/",
"}",
"/",
"/",
"note",
":",
"each",
"offset",
"value",
"is",
"into",
"an",
"array",
"of",
"structures",
"that",
"are",
"12",
"bytes",
"in",
"length",
",",
"but",
"/",
"/",
"whose",
"on",
"-",
"disk",
"size",
"is",
"8",
"bytes",
"these",
"are",
"the",
"structures",
"in",
"the",
"hash",
"records",
"reader",
"so",
"/",
"/",
"take",
"the",
"offset",
"and",
"multiple",
"by",
"2",
"/",
"3",
"to",
"get",
"the",
"byte",
"offset",
"into",
"the",
"reader",
"for",
"the",
"/",
"/",
"actual",
"record",
"still",
"need",
"to",
"deal",
"with",
"the",
"collision",
"logic",
"after",
"that",
"deserialize",
"hash",
"records",
"(",
"hash",
"records",
"reader",
",",
"monitor",
")",
";",
"}"
] |
[
"a",
"timeout",
"value",
"in",
"case",
"the",
"master",
"has",
"not",
"been",
"discovered",
"yet",
"or",
"disconnected"
] | [
"public",
"final",
"request",
"master",
"node",
"timeout",
"(",
"string",
"timeout",
")",
"{",
"return",
"master",
"node",
"timeout",
"(",
"time",
"value",
"parse",
"time",
"value",
"(",
"timeout",
",",
"null",
",",
"get",
"class",
"(",
")",
"get",
"simple",
"name",
"(",
")",
"+",
"\"",
"master",
"node",
"timeout",
"\"",
")",
")",
";",
"}"
] |
[
"gets",
"the",
"number",
"of",
"the",
"superstep",
",",
"starting",
"at",
"<",
"tt",
">",
"1",
"<",
"tt",
">"
] | [
"public",
"int",
"get",
"superstep",
"number",
"(",
")",
"{",
"return",
"this",
"runtime",
"context",
"get",
"superstep",
"number",
"(",
")",
";",
"}"
] |
[
"current",
"protocol",
"configuration",
",",
"to",
"replace",
"xml",
"config",
":",
"<",
"prev",
">",
"&",
"lt",
";",
"dubbo",
":",
"protocol",
"name",
"=",
"\"",
"dubbo",
"\"",
"port",
"=",
"\"",
"12345",
"\"",
"&",
"gt",
";",
"<",
"prev",
">"
] | [
"public",
"protocol",
"config",
"protocol",
"config",
"(",
")",
"{",
"protocol",
"config",
"protocol",
"config",
"=",
"new",
"protocol",
"config",
"(",
")",
";",
"protocol",
"config",
"set",
"name",
"(",
"\"",
"dubbo",
"\"",
")",
";",
"protocol",
"config",
"set",
"port",
"(",
"12345",
")",
";",
"return",
"protocol",
"config",
";",
"}"
] |
[
"returns",
"the",
"principal",
"name",
"(",
"this",
"method",
"name",
"comes",
"from",
"the",
"jdk",
"{",
"@",
"link",
"principal",
"}",
"interface",
")"
] | [
"public",
"string",
"get",
"name",
"(",
")",
"{",
"return",
"principal",
";",
"}"
] |
[
"join",
"an",
"existing",
"transaction",
",",
"if",
"not",
"already",
"joined"
] | [
"private",
"void",
"do",
"join",
"transaction",
"(",
"boolean",
"enforce",
")",
"{",
"if",
"(",
"this",
"jta",
")",
"{",
"/",
"/",
"let",
"'",
"s",
"try",
"whether",
"we",
"'",
"re",
"in",
"a",
"jta",
"transaction",
"try",
"{",
"this",
"target",
"join",
"transaction",
"(",
")",
";",
"logger",
"debug",
"(",
"\"",
"joined",
"jta",
"transaction",
"\"",
")",
";",
"}",
"catch",
"(",
"transaction",
"required",
"exception",
"ex",
")",
"{",
"if",
"(",
"!",
"enforce",
")",
"{",
"logger",
"debug",
"(",
"\"",
"no",
"jta",
"transaction",
"to",
"join",
":",
"\"",
"+",
"ex",
")",
";",
"}",
"else",
"{",
"throw",
"ex",
";",
"}",
"}",
"}",
"else",
"{",
"if",
"(",
"transaction",
"synchronization",
"manager",
"is",
"synchronization",
"active",
"(",
")",
")",
"{",
"if",
"(",
"!",
"transaction",
"synchronization",
"manager",
"has",
"resource",
"(",
"this",
"target",
")",
"&",
"&",
"!",
"this",
"target",
"get",
"transaction",
"(",
")",
"is",
"active",
"(",
")",
")",
"{",
"enlist",
"in",
"current",
"transaction",
"(",
")",
";",
"}",
"logger",
"debug",
"(",
"\"",
"joined",
"local",
"transaction",
"\"",
")",
";",
"}",
"else",
"{",
"if",
"(",
"!",
"enforce",
")",
"{",
"logger",
"debug",
"(",
"\"",
"no",
"local",
"transaction",
"to",
"join",
"\"",
")",
";",
"}",
"else",
"{",
"throw",
"new",
"transaction",
"required",
"exception",
"(",
"\"",
"no",
"local",
"transaction",
"to",
"join",
"\"",
")",
";",
"}",
"}",
"}",
"}"
] |
[
"mount",
"a",
"component",
"into",
"a",
"component",
"view"
] | [
"public",
"static",
"litho",
"view",
"mount",
"component",
"(",
"component",
"context",
"context",
",",
"component",
"component",
",",
"boolean",
"incremental",
"mount",
"enabled",
",",
"boolean",
"visibility",
"processing",
"enabled",
")",
"{",
"return",
"mount",
"component",
"(",
"context",
",",
"new",
"litho",
"view",
"(",
"context",
")",
",",
"component",
",",
"incremental",
"mount",
"enabled",
",",
"visibility",
"processing",
"enabled",
",",
"100",
",",
"100",
")",
";",
"}"
] |
[
"sets",
"the",
"type",
"of",
"interpolation",
"{",
"@",
"link",
"filter",
"}",
"to",
"be",
"used",
"in",
"conjunction",
"with",
"{",
"@",
"link",
"pixmap",
"#",
"draw",
"pixmap",
"(",
"pixmap",
",",
"int",
",",
"int",
",",
"int",
",",
"int",
",",
"int",
",",
"int",
",",
"int",
",",
"int",
")",
"}"
] | [
"public",
"void",
"set",
"filter",
"(",
"filter",
"filter",
")",
"{",
"this",
"filter",
"=",
"filter",
";",
"}"
] |
[
"processes",
"prelink",
"and",
"macho",
"-",
"o",
"offsets",
"in",
"order",
"to",
"map",
"files",
"to",
"their",
"mach",
"-",
"o",
"offsets",
"in",
"the",
"providers"
] | [
"private",
"void",
"process",
"prelink",
"with",
"macho",
"(",
"list",
"<",
"prelink",
"map",
">",
"prelink",
"list",
",",
"list",
"<",
"long",
">",
"macho",
"header",
"offsets",
",",
"task",
"monitor",
"monitor",
")",
"throws",
"i",
"o",
"exception",
",",
"mach",
"exception",
"{",
"monitor",
"set",
"message",
"(",
"\"",
"processing",
"prelink",
"with",
"found",
"mach",
"-",
"o",
"headers",
"\"",
")",
";",
"monitor",
"initialize",
"(",
"prelink",
"list",
"size",
"(",
")",
")",
";",
"bidi",
"map",
"<",
"prelink",
"map",
",",
"long",
">",
"map",
"=",
"macho",
"prelink",
"utils",
"match",
"prelink",
"to",
"macho",
"header",
"offsets",
"(",
"provider",
",",
"prelink",
"list",
",",
"macho",
"header",
"offsets",
",",
"monitor",
")",
";",
"for",
"(",
"prelink",
"map",
"info",
":",
"map",
"key",
"set",
"(",
")",
")",
"{",
"if",
"(",
"monitor",
"is",
"cancelled",
"(",
")",
")",
"{",
"break",
";",
"}",
"monitor",
"increment",
"progress",
"(",
"1",
")",
";",
"if",
"(",
"info",
"get",
"prelink",
"bundle",
"path",
"(",
")",
"=",
"=",
"null",
")",
"{",
"continue",
";",
"}",
"/",
"/",
"the",
"following",
"could",
"end",
"up",
"being",
"a",
"directory",
"once",
"we",
"discover",
"it",
"has",
"a",
"child",
"we",
"'",
"ll",
"/",
"/",
"handle",
"that",
"in",
"store",
"file",
"(",
")",
"g",
"file",
"impl",
"file",
"=",
"g",
"file",
"impl",
"from",
"path",
"string",
"(",
"this",
",",
"root",
",",
"info",
"get",
"prelink",
"bundle",
"path",
"(",
")",
",",
"null",
",",
"false",
",",
"0",
")",
";",
"if",
"(",
"info",
"get",
"prelink",
"executable",
"size",
"(",
")",
">",
"-",
"1",
")",
"{",
"file",
"set",
"length",
"(",
"info",
"get",
"prelink",
"executable",
"size",
"(",
")",
")",
";",
"}",
"file",
"=",
"store",
"file",
"(",
"file",
",",
"info",
")",
";",
"if",
"(",
"is",
"child",
"of",
"(",
"system",
"kext",
"file",
",",
"file",
")",
")",
"{",
"continue",
";",
"}",
"file",
"to",
"macho",
"offset",
"map",
"put",
"(",
"file",
",",
"map",
"get",
"(",
"info",
")",
")",
";",
"}",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.