docstring_tokens
list | code_tokens
list |
|---|---|
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"any",
"element",
"in",
"{",
"@",
"code",
"iterable",
"}",
"satisfies",
"the",
"predicate",
"<",
"b",
">",
"{",
"@",
"code",
"stream",
"}",
"equivalent",
":",
"<",
"b",
">",
"{",
"@",
"link",
"stream",
"#",
"any",
"match",
"}"
]
| [
"public",
"static",
"<",
"t",
">",
"boolean",
"any",
"(",
"iterable",
"<",
"t",
">",
"iterable",
",",
"predicate",
"<",
"?",
"super",
"t",
">",
"predicate",
")",
"{",
"return",
"iterators",
"any",
"(",
"iterable",
"iterator",
"(",
")",
",",
"predicate",
")",
";",
"}"
]
|
[
"retrieve",
"the",
"most",
"specific",
"cause",
"of",
"this",
"exception",
",",
"that",
"is",
",",
"either",
"the",
"innermost",
"cause",
"(",
"root",
"cause",
")",
"or",
"this",
"exception",
"itself",
"differs",
"from",
"{",
"@",
"link",
"#",
"get",
"root",
"cause",
"(",
")",
"}",
"in",
"that",
"it",
"falls",
"back",
"to",
"the",
"present",
"exception",
"if",
"there",
"is",
"no",
"root",
"cause"
]
| [
"public",
"throwable",
"get",
"most",
"specific",
"cause",
"(",
")",
"{",
"throwable",
"root",
"cause",
"=",
"get",
"root",
"cause",
"(",
")",
";",
"return",
"(",
"root",
"cause",
"!",
"=",
"null",
"?",
"root",
"cause",
":",
"this",
")",
";",
"}"
]
|
[
"empties",
"out",
"the",
"edge",
"set",
"while",
"leaving",
"the",
"capacity",
"alone",
"much",
"faster",
"than",
"removing",
"the",
"edges",
"one",
"by",
"one"
]
| [
"public",
"void",
"clear",
"(",
")",
"{",
"if",
"(",
"size",
"(",
")",
">",
"0",
")",
"{",
"edge",
"indices",
"remove",
"all",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"capacity",
";",
"i",
"+",
"+",
")",
"{",
"edges",
"[",
"i",
"]",
"=",
"null",
";",
"previous",
"edge",
"with",
"same",
"from",
"[",
"i",
"]",
"=",
"null",
";",
"previous",
"edge",
"with",
"same",
"to",
"[",
"i",
"]",
"=",
"null",
";",
"next",
"edge",
"with",
"same",
"from",
"[",
"i",
"]",
"=",
"null",
";",
"next",
"edge",
"with",
"same",
"to",
"[",
"i",
"]",
"=",
"null",
";",
"}",
"}",
"next",
"index",
"=",
"0",
";",
"modification",
"number",
"+",
"+",
";",
"}"
]
|
[
"convenience",
"wrapper",
"method",
"around",
"{",
"@",
"link",
"#",
"schedule",
"2",
"(",
"task",
",",
"int",
",",
"list",
")",
"}"
]
| [
"public",
"@",
"non",
"null",
"schedule",
"result",
"schedule",
"2",
"(",
"task",
"p",
",",
"int",
"quiet",
"period",
",",
"action",
"actions",
")",
"{",
"return",
"schedule",
"2",
"(",
"p",
",",
"quiet",
"period",
",",
"arrays",
"as",
"list",
"(",
"actions",
")",
")",
";",
"}"
]
|
[
"called",
"from",
"the",
"drop",
"tgt",
"adapter",
"when",
"the",
"drag",
"operation",
"is",
"going",
"over",
"a",
"drop",
"site",
";",
"indicate",
"when",
"the",
"drop",
"is",
"ok",
"by",
"providing",
"appropriate",
"feedback"
]
| [
"public",
"void",
"drag",
"under",
"feedback",
"(",
"boolean",
"ok",
",",
"drop",
"target",
"drag",
"event",
"e",
")",
"{",
"synchronized",
"(",
"table",
")",
"{",
"int",
"drop",
"action",
"=",
"e",
"get",
"drop",
"action",
"(",
")",
";",
"boolean",
"action",
"changed",
"=",
"false",
";",
"if",
"(",
"drop",
"action",
"!",
"=",
"last",
"dnd",
"action",
")",
"{",
"action",
"changed",
"=",
"true",
";",
"last",
"dnd",
"action",
"=",
"drop",
"action",
";",
"}",
"if",
"(",
"table",
"is",
"editing",
"(",
")",
")",
"{",
"table",
"editing",
"canceled",
"(",
"null",
")",
";",
"}",
"dnd",
"table",
"cell",
"renderer",
"select",
"range",
"(",
"true",
")",
";",
"dnd",
"dti",
"cell",
"renderer",
"select",
"range",
"(",
"true",
")",
";",
"point",
"p",
"=",
"e",
"get",
"location",
"(",
")",
";",
"int",
"row",
"=",
"table",
"row",
"at",
"point",
"(",
"p",
")",
";",
"boolean",
"set",
"row",
"=",
"dnd",
"table",
"cell",
"renderer",
"set",
"row",
"for",
"feedback",
"(",
"row",
")",
";",
"boolean",
"set",
"dti",
"row",
"=",
"dnd",
"dti",
"cell",
"renderer",
"set",
"row",
"for",
"feedback",
"(",
"row",
")",
";",
"if",
"(",
"action",
"changed",
"|",
"|",
"set",
"row",
"|",
"|",
"set",
"dti",
"row",
")",
"{",
"table",
"repaint",
"(",
")",
";",
"}",
"}",
"}"
]
|
[
"adapt",
"the",
"{",
"@",
"code",
"entry",
"}",
"into",
"a",
"downstream",
"metrics",
"{",
"@",
"link",
"service",
"mesh",
"metric",
"builder",
"}"
]
| [
"public",
"service",
"mesh",
"metric",
"builder",
"adapt",
"to",
"downstream",
"metrics",
"(",
")",
"{",
"final",
"access",
"log",
"common",
"properties",
"=",
"entry",
"get",
"common",
"properties",
"(",
")",
";",
"final",
"long",
"start",
"time",
"=",
"format",
"as",
"long",
"(",
"properties",
"get",
"start",
"time",
"(",
")",
")",
";",
"final",
"long",
"duration",
"=",
"format",
"as",
"long",
"(",
"properties",
"get",
"time",
"to",
"last",
"downstream",
"tx",
"byte",
"(",
")",
")",
";",
"return",
"adapt",
"common",
"part",
"(",
")",
"set",
"start",
"time",
"(",
"start",
"time",
")",
"set",
"end",
"time",
"(",
"start",
"time",
"+",
"duration",
")",
"set",
"latency",
"(",
"(",
"int",
")",
"math",
"max",
"(",
"1l",
",",
"duration",
")",
")",
"set",
"detect",
"point",
"(",
"detect",
"point",
"server",
")",
";",
"}"
]
|
[
"whether",
"the",
"value",
"can",
"be",
"overridden",
"<",
"code",
">",
"optional",
"bool",
"weak",
"=",
"3",
";",
"<",
"code",
">"
]
| [
"public",
"boolean",
"get",
"weak",
"(",
")",
"{",
"return",
"instance",
"get",
"weak",
"(",
")",
";",
"}"
]
|
[
"makes",
"sure",
"that",
"the",
"given",
"name",
"is",
"good",
"as",
"an",
"agent",
"name"
]
| [
"public",
"form",
"validation",
"do",
"check",
"name",
"(",
"@",
"query",
"parameter",
"string",
"value",
")",
"throws",
"i",
"o",
"exception",
",",
"servlet",
"exception",
"{",
"jenkins",
"get",
"(",
")",
"check",
"permission",
"(",
"computer",
"create",
")",
";",
"if",
"(",
"util",
"fix",
"empty",
"(",
"value",
")",
"=",
"=",
"null",
")",
"return",
"form",
"validation",
"ok",
"(",
")",
";",
"try",
"{",
"check",
"name",
"(",
"value",
")",
";",
"return",
"form",
"validation",
"ok",
"(",
")",
";",
"}",
"catch",
"(",
"failure",
"e",
")",
"{",
"return",
"form",
"validation",
"error",
"(",
"e",
"get",
"message",
"(",
")",
")",
";",
"}",
"}"
]
|
[
"resolves",
"a",
"url",
"for",
"the",
"underlying",
"class",
"path",
"resource"
]
| [
"protected",
"url",
"resolve",
"u",
"r",
"l",
"(",
")",
"{",
"if",
"(",
"this",
"clazz",
"!",
"=",
"null",
")",
"{",
"return",
"this",
"clazz",
"get",
"resource",
"(",
"this",
"path",
")",
";",
"}",
"else",
"if",
"(",
"this",
"class",
"loader",
"!",
"=",
"null",
")",
"{",
"return",
"this",
"class",
"loader",
"get",
"resource",
"(",
"this",
"path",
")",
";",
"}",
"else",
"{",
"return",
"class",
"loader",
"get",
"system",
"resource",
"(",
"this",
"path",
")",
";",
"}",
"}"
]
|
[
"removes",
"an",
"item",
"from",
"the",
"list"
]
| [
"public",
"synchronized",
"boolean",
"remove",
"(",
"e",
"e",
")",
"{",
"list",
"<",
"e",
">",
"n",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"core",
")",
";",
"boolean",
"r",
"=",
"n",
"remove",
"(",
"e",
")",
";",
"core",
"=",
"n",
";",
"return",
"r",
";",
"}"
]
|
[
"allocates",
"the",
"given",
"slot",
"this",
"entails",
"sending",
"a",
"registration",
"message",
"to",
"the",
"task",
"manager",
"and",
"treating",
"failures"
]
| [
"private",
"void",
"allocate",
"slot",
"(",
"task",
"manager",
"slot",
"information",
"task",
"manager",
"slot",
",",
"job",
"i",
"d",
"job",
"id",
",",
"string",
"target",
"address",
",",
"resource",
"profile",
"resource",
"profile",
")",
"{",
"final",
"slot",
"i",
"d",
"slot",
"id",
"=",
"task",
"manager",
"slot",
"get",
"slot",
"id",
"(",
")",
";",
"log",
"debug",
"(",
"\"",
"starting",
"allocation",
"of",
"slot",
"{",
"}",
"for",
"job",
"{",
"}",
"with",
"resource",
"profile",
"{",
"}",
"\"",
",",
"slot",
"id",
",",
"job",
"id",
",",
"resource",
"profile",
")",
";",
"final",
"instance",
"i",
"d",
"instance",
"id",
"=",
"task",
"manager",
"slot",
"get",
"instance",
"id",
"(",
")",
";",
"if",
"(",
"!",
"task",
"executor",
"manager",
"is",
"task",
"manager",
"registered",
"(",
"instance",
"id",
")",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"could",
"not",
"find",
"a",
"registered",
"task",
"manager",
"for",
"instance",
"id",
"\"",
"+",
"instance",
"id",
"+",
"'",
"'",
")",
";",
"}",
"final",
"task",
"executor",
"connection",
"task",
"executor",
"connection",
"=",
"task",
"manager",
"slot",
"get",
"task",
"manager",
"connection",
"(",
")",
";",
"final",
"task",
"executor",
"gateway",
"gateway",
"=",
"task",
"executor",
"connection",
"get",
"task",
"executor",
"gateway",
"(",
")",
";",
"slot",
"tracker",
"notify",
"allocation",
"start",
"(",
"slot",
"id",
",",
"job",
"id",
")",
";",
"task",
"executor",
"manager",
"mark",
"used",
"(",
"instance",
"id",
")",
";",
"pending",
"slot",
"allocations",
"add",
"(",
"slot",
"id",
")",
";",
"/",
"/",
"rpc",
"call",
"to",
"the",
"task",
"manager",
"completable",
"future",
"<",
"acknowledge",
">",
"request",
"future",
"=",
"gateway",
"request",
"slot",
"(",
"slot",
"id",
",",
"job",
"id",
",",
"new",
"allocation",
"i",
"d",
"(",
")",
",",
"resource",
"profile",
",",
"target",
"address",
",",
"resource",
"manager",
"id",
",",
"task",
"manager",
"request",
"timeout",
")",
";",
"completable",
"future",
"<",
"void",
">",
"slot",
"allocation",
"response",
"processing",
"future",
"=",
"request",
"future",
"handle",
"async",
"(",
"(",
"acknowledge",
"acknowledge",
",",
"throwable",
"throwable",
")",
"-",
">",
"{",
"if",
"(",
"!",
"pending",
"slot",
"allocations",
"contains",
"(",
"slot",
"id",
")",
")",
"{",
"log",
"debug",
"(",
"\"",
"ignoring",
"slot",
"allocation",
"update",
"from",
"task",
"executor",
"{",
"}",
"for",
"slot",
"{",
"}",
"and",
"job",
"{",
"}",
",",
"because",
"the",
"allocation",
"was",
"already",
"completed",
"or",
"cancelled",
"\"",
",",
"instance",
"id",
",",
"slot",
"id",
",",
"job",
"id",
")",
";",
"return",
"null",
";",
"}",
"if",
"(",
"acknowledge",
"!",
"=",
"null",
")",
"{",
"log",
"trace",
"(",
"\"",
"completed",
"allocation",
"of",
"slot",
"{",
"}",
"for",
"job",
"{",
"}",
"\"",
",",
"slot",
"id",
",",
"job",
"id",
")",
";",
"slot",
"tracker",
"notify",
"allocation",
"complete",
"(",
"slot",
"id",
",",
"job",
"id",
")",
";",
"}",
"else",
"{",
"if",
"(",
"throwable",
"instanceof",
"slot",
"occupied",
"exception",
")",
"{",
"slot",
"occupied",
"exception",
"exception",
"=",
"(",
"slot",
"occupied",
"exception",
")",
"throwable",
";",
"log",
"debug",
"(",
"\"",
"tried",
"allocating",
"slot",
"{",
"}",
"for",
"job",
"{",
"}",
",",
"but",
"it",
"was",
"already",
"allocated",
"for",
"job",
"{",
"}",
"\"",
",",
"slot",
"id",
",",
"job",
"id",
",",
"exception",
"get",
"job",
"id",
"(",
")",
")",
";",
"/",
"/",
"report",
"as",
"a",
"slot",
"status",
"to",
"force",
"the",
"state",
"transition",
"/",
"/",
"this",
"could",
"be",
"a",
"problem",
"if",
"we",
"ever",
"assume",
"that",
"the",
"task",
"/",
"/",
"executor",
"always",
"reports",
"about",
"all",
"slots",
"slot",
"tracker",
"notify",
"slot",
"status",
"(",
"collections",
"singleton",
"(",
"new",
"slot",
"status",
"(",
"slot",
"id",
",",
"task",
"manager",
"slot",
"get",
"resource",
"profile",
"(",
")",
",",
"exception",
"get",
"job",
"id",
"(",
")",
",",
"exception",
"get",
"allocation",
"id",
"(",
")",
")",
")",
")",
";",
"}",
"else",
"{",
"log",
"warn",
"(",
"\"",
"slot",
"allocation",
"for",
"slot",
"{",
"}",
"for",
"job",
"{",
"}",
"failed",
"\"",
",",
"slot",
"id",
",",
"job",
"id",
",",
"throwable",
")",
";",
"slot",
"tracker",
"notify",
"free",
"(",
"slot",
"id",
")",
";",
"}",
"check",
"resource",
"requirements",
"(",
")",
";",
"}",
"return",
"null",
";",
"}",
",",
"main",
"thread",
"executor",
")",
";",
"future",
"utils",
"assert",
"no",
"exception",
"(",
"slot",
"allocation",
"response",
"processing",
"future",
")",
";",
"}"
]
|
[
"update",
"an",
"existing",
"pet"
]
| [
"public",
"void",
"update",
"pet",
"test",
"(",
")",
"throws",
"api",
"exception",
"{",
"/",
"/",
"pet",
"pet",
"=",
"null",
";",
"/",
"/",
"api",
"update",
"pet",
"(",
"pet",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
]
|
[
"get",
"start",
"time",
"of",
"the",
"task"
]
| [
"public",
"long",
"get",
"start",
"time",
"(",
")",
"{",
"return",
"start",
"time",
";",
"}"
]
|
[
"appends",
"a",
"{",
"@",
"code",
"float",
"}",
"value",
"to",
"the",
"stream",
"this",
"corresponds",
"to",
"the",
"{",
"@",
"code",
"float",
"3",
"2",
"}",
"value",
"type",
"in",
"the",
"ubjson",
"specification"
]
| [
"public",
"u",
"b",
"json",
"writer",
"value",
"(",
"float",
"value",
")",
"throws",
"i",
"o",
"exception",
"{",
"check",
"name",
"(",
")",
";",
"out",
"write",
"byte",
"(",
"'",
"d",
"'",
")",
";",
"out",
"write",
"float",
"(",
"value",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"forwards",
"the",
"request",
"to",
"the",
"next",
"filter",
"in",
"the",
"chain",
"and",
"delegates",
"down",
"to",
"the",
"subclasses",
"to",
"perform",
"the",
"actual",
"request",
"logging",
"both",
"before",
"and",
"after",
"the",
"request",
"is",
"processed"
]
| [
"protected",
"void",
"do",
"filter",
"internal",
"(",
"http",
"servlet",
"request",
"request",
",",
"http",
"servlet",
"response",
"response",
",",
"filter",
"chain",
"filter",
"chain",
")",
"throws",
"servlet",
"exception",
",",
"i",
"o",
"exception",
"{",
"boolean",
"is",
"first",
"request",
"=",
"!",
"is",
"async",
"dispatch",
"(",
"request",
")",
";",
"http",
"servlet",
"request",
"request",
"to",
"use",
"=",
"request",
";",
"if",
"(",
"is",
"include",
"payload",
"(",
")",
"&",
"&",
"is",
"first",
"request",
"&",
"&",
"!",
"(",
"request",
"instanceof",
"content",
"caching",
"request",
"wrapper",
")",
")",
"{",
"request",
"to",
"use",
"=",
"new",
"content",
"caching",
"request",
"wrapper",
"(",
"request",
",",
"get",
"max",
"payload",
"length",
"(",
")",
")",
";",
"}",
"boolean",
"should",
"log",
"=",
"should",
"log",
"(",
"request",
"to",
"use",
")",
";",
"if",
"(",
"should",
"log",
"&",
"&",
"is",
"first",
"request",
")",
"{",
"before",
"request",
"(",
"request",
"to",
"use",
",",
"get",
"before",
"message",
"(",
"request",
"to",
"use",
")",
")",
";",
"}",
"try",
"{",
"filter",
"chain",
"do",
"filter",
"(",
"request",
"to",
"use",
",",
"response",
")",
";",
"}",
"finally",
"{",
"if",
"(",
"should",
"log",
"&",
"&",
"!",
"is",
"async",
"started",
"(",
"request",
"to",
"use",
")",
")",
"{",
"after",
"request",
"(",
"request",
"to",
"use",
",",
"get",
"after",
"message",
"(",
"request",
"to",
"use",
")",
")",
";",
"}",
"}",
"}"
]
|
[
"decodes",
"and",
"returns",
"the",
"next",
"symbol"
]
| [
"int",
"next",
"symbol",
"(",
")",
"{",
"/",
"/",
"move",
"to",
"next",
"group",
"selector",
"if",
"required",
"if",
"(",
"+",
"+",
"group",
"position",
"%",
"huffman",
"group",
"run",
"length",
"=",
"=",
"0",
")",
"{",
"group",
"index",
"+",
"+",
";",
"if",
"(",
"group",
"index",
"=",
"=",
"selectors",
"length",
")",
"{",
"throw",
"new",
"decompression",
"exception",
"(",
"\"",
"error",
"decoding",
"block",
"\"",
")",
";",
"}",
"current",
"table",
"=",
"selectors",
"[",
"group",
"index",
"]",
"&",
"0xff",
";",
"}",
"final",
"bzip",
"2",
"bit",
"reader",
"reader",
"=",
"this",
"reader",
";",
"final",
"int",
"current",
"table",
"=",
"this",
"current",
"table",
";",
"final",
"int",
"[",
"]",
"table",
"limits",
"=",
"code",
"limits",
"[",
"current",
"table",
"]",
";",
"final",
"int",
"[",
"]",
"table",
"bases",
"=",
"code",
"bases",
"[",
"current",
"table",
"]",
";",
"final",
"int",
"[",
"]",
"table",
"symbols",
"=",
"code",
"symbols",
"[",
"current",
"table",
"]",
";",
"int",
"code",
"length",
"=",
"minimum",
"lengths",
"[",
"current",
"table",
"]",
";",
"/",
"/",
"starting",
"with",
"the",
"minimum",
"bit",
"length",
"for",
"the",
"table",
",",
"read",
"additional",
"bits",
"one",
"at",
"a",
"time",
"/",
"/",
"until",
"a",
"complete",
"code",
"is",
"recognised",
"int",
"code",
"bits",
"=",
"reader",
"read",
"bits",
"(",
"code",
"length",
")",
";",
"for",
"(",
";",
"code",
"length",
"<",
"=",
"huffman",
"decode",
"max",
"code",
"length",
";",
"code",
"length",
"+",
"+",
")",
"{",
"if",
"(",
"code",
"bits",
"<",
"=",
"table",
"limits",
"[",
"code",
"length",
"]",
")",
"{",
"/",
"/",
"convert",
"the",
"code",
"to",
"a",
"symbol",
"index",
"and",
"return",
"return",
"table",
"symbols",
"[",
"code",
"bits",
"-",
"table",
"bases",
"[",
"code",
"length",
"]",
"]",
";",
"}",
"code",
"bits",
"=",
"code",
"bits",
"<",
"<",
"1",
"|",
"reader",
"read",
"bits",
"(",
"1",
")",
";",
"}",
"throw",
"new",
"decompression",
"exception",
"(",
"\"",
"a",
"valid",
"code",
"was",
"not",
"recognised",
"\"",
")",
";",
"}"
]
|
[
"obtain",
"a",
"new",
"method",
"parameter",
"object",
"for",
"the",
"write",
"method",
"of",
"the",
"specified",
"property"
]
| [
"public",
"static",
"method",
"parameter",
"get",
"write",
"method",
"parameter",
"(",
"property",
"descriptor",
"pd",
")",
"{",
"if",
"(",
"pd",
"instanceof",
"generic",
"type",
"aware",
"property",
"descriptor",
")",
"{",
"return",
"new",
"method",
"parameter",
"(",
"(",
"(",
"generic",
"type",
"aware",
"property",
"descriptor",
")",
"pd",
")",
"get",
"write",
"method",
"parameter",
"(",
")",
")",
";",
"}",
"else",
"{",
"method",
"write",
"method",
"=",
"pd",
"get",
"write",
"method",
"(",
")",
";",
"assert",
"state",
"(",
"write",
"method",
"!",
"=",
"null",
",",
"\"",
"no",
"write",
"method",
"available",
"\"",
")",
";",
"return",
"new",
"method",
"parameter",
"(",
"write",
"method",
",",
"0",
")",
";",
"}",
"}"
]
|
[
"returns",
"the",
"number",
"of",
"bits",
"in",
"this",
"hash",
"code",
";",
"a",
"positive",
"multiple",
"of",
"8"
]
| [
"public",
"abstract",
"int",
"bits",
"(",
")",
";"
]
|
[
"this",
"saves",
"bindings",
"that",
"users",
"have",
"changed",
"these",
"will",
"overwrite",
"those",
"that",
"may",
"be",
"defined",
"in",
"the",
"script"
]
| [
"void",
"save",
"user",
"defined",
"keybindings",
"(",
"save",
"state",
"save",
"state",
")",
"{",
"collection",
"<",
"script",
"action",
">",
"actions",
"=",
"action",
"map",
"values",
"(",
")",
";",
"for",
"(",
"script",
"action",
"action",
":",
"actions",
")",
"{",
"if",
"(",
"!",
"action",
"is",
"user",
"defined",
"key",
"binding",
"(",
")",
")",
"{",
"continue",
";",
"}",
"resource",
"file",
"script",
"file",
"=",
"action",
"get",
"script",
"(",
")",
";",
"script",
"info",
"info",
"=",
"info",
"manager",
"get",
"existing",
"script",
"info",
"(",
"script",
"file",
")",
";",
"if",
"(",
"info",
"=",
"=",
"null",
")",
"{",
"msg",
"show",
"error",
"(",
"this",
",",
"provider",
"get",
"component",
"(",
")",
",",
"\"",
"bad",
"state",
"?",
"\"",
",",
"\"",
"action",
"associated",
"with",
"a",
"script",
"that",
"has",
"no",
"info",
"\"",
")",
";",
"continue",
";",
"/",
"/",
"bad",
"state",
"?",
"}",
"key",
"stroke",
"stroke",
"=",
"action",
"get",
"key",
"binding",
"(",
")",
";",
"if",
"(",
"stroke",
"=",
"=",
"null",
")",
"{",
"save",
"state",
"put",
"string",
"(",
"script",
"file",
"get",
"name",
"(",
")",
",",
"\"",
"\"",
")",
";",
"}",
"else",
"{",
"string",
"stroke",
"str",
"=",
"key",
"binding",
"utils",
"parse",
"key",
"stroke",
"(",
"stroke",
")",
";",
"save",
"state",
"put",
"string",
"(",
"script",
"file",
"get",
"name",
"(",
")",
",",
"stroke",
"str",
")",
";",
"}",
"}",
"}"
]
|
[
"request",
"that",
"any",
"state",
"maintained",
"by",
"the",
"delegate",
"editor",
"pertaining",
"to",
"column",
"data",
"be",
"cleared"
]
| [
"public",
"void",
"clear",
"column",
"data",
"(",
")",
"{",
"/",
"/",
"do",
"nothing",
";",
"left",
"for",
"subclasses",
"to",
"implement",
"}"
]
|
[
"{",
"@",
"link",
"abfs",
"input",
"stream",
"}",
"calls",
"this",
"method",
"read",
"any",
"bytes",
"already",
"available",
"in",
"a",
"buffer",
"(",
"thereby",
"saving",
"a",
"remote",
"read",
")",
"this",
"returns",
"the",
"bytes",
"if",
"the",
"data",
"already",
"exists",
"in",
"buffer",
"if",
"there",
"is",
"a",
"buffer",
"that",
"is",
"reading",
"the",
"requested",
"offset",
",",
"then",
"this",
"method",
"blocks",
"until",
"that",
"read",
"completes",
"if",
"the",
"data",
"is",
"queued",
"in",
"a",
"read",
"-",
"ahead",
"but",
"not",
"picked",
"up",
"by",
"a",
"worker",
"thread",
"yet",
",",
"then",
"it",
"cancels",
"that",
"read",
"-",
"ahead",
"and",
"reports",
"cache",
"miss",
"this",
"is",
"because",
"depending",
"on",
"worker",
"thread",
"availability",
",",
"the",
"read",
"-",
"ahead",
"may",
"take",
"a",
"while",
"-",
"the",
"calling",
"thread",
"can",
"do",
"it",
"'",
"s",
"own",
"read",
"to",
"get",
"the",
"data",
"faster",
"(",
"copmared",
"to",
"the",
"read",
"waiting",
"in",
"queue",
"for",
"an",
"indeterminate",
"amount",
"of",
"time",
")"
]
| [
"int",
"get",
"block",
"(",
"final",
"abfs",
"input",
"stream",
"stream",
",",
"final",
"long",
"position",
",",
"final",
"int",
"length",
",",
"final",
"byte",
"[",
"]",
"buffer",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"/",
"not",
"synchronized",
",",
"so",
"have",
"to",
"be",
"careful",
"with",
"locking",
"if",
"(",
"logger",
"is",
"trace",
"enabled",
"(",
")",
")",
"{",
"logger",
"trace",
"(",
"\"",
"get",
"block",
"for",
"file",
"{",
"}",
"position",
"{",
"}",
"thread",
"{",
"}",
"\"",
",",
"stream",
"get",
"path",
"(",
")",
",",
"position",
",",
"thread",
"current",
"thread",
"(",
")",
"get",
"name",
"(",
")",
")",
";",
"}",
"wait",
"for",
"process",
"(",
"stream",
",",
"position",
")",
";",
"int",
"bytes",
"read",
"=",
"0",
";",
"synchronized",
"(",
"this",
")",
"{",
"bytes",
"read",
"=",
"get",
"block",
"from",
"completed",
"queue",
"(",
"stream",
",",
"position",
",",
"length",
",",
"buffer",
")",
";",
"}",
"if",
"(",
"bytes",
"read",
">",
"0",
")",
"{",
"if",
"(",
"logger",
"is",
"trace",
"enabled",
"(",
")",
")",
"{",
"logger",
"trace",
"(",
"\"",
"done",
"read",
"from",
"cache",
"for",
"{",
"}",
"position",
"{",
"}",
"length",
"{",
"}",
"\"",
",",
"stream",
"get",
"path",
"(",
")",
",",
"position",
",",
"bytes",
"read",
")",
";",
"}",
"return",
"bytes",
"read",
";",
"}",
"/",
"/",
"otherwise",
",",
"just",
"say",
"we",
"got",
"nothing",
"-",
"calling",
"thread",
"can",
"do",
"its",
"own",
"read",
"return",
"0",
";",
"}"
]
|
[
"visit",
"a",
"parse",
"tree",
"produced",
"by",
"{",
"@",
"link",
"eql",
"base",
"parser",
"#",
"string",
"}"
]
| [
"t",
"visit",
"string",
"(",
"eql",
"base",
"parser",
"string",
"context",
"ctx",
")",
";"
]
|
[
"stop",
"the",
"shared",
"connection",
",",
"call",
"{",
"@",
"link",
"#",
"do",
"shutdown",
"(",
")",
"}",
",",
"and",
"close",
"this",
"container"
]
| [
"public",
"void",
"shutdown",
"(",
")",
"throws",
"jms",
"exception",
"{",
"logger",
"debug",
"(",
"\"",
"shutting",
"down",
"jms",
"listener",
"container",
"\"",
")",
";",
"boolean",
"was",
"running",
";",
"synchronized",
"(",
"this",
"lifecycle",
"monitor",
")",
"{",
"was",
"running",
"=",
"this",
"running",
";",
"this",
"running",
"=",
"false",
";",
"this",
"active",
"=",
"false",
";",
"this",
"paused",
"tasks",
"clear",
"(",
")",
";",
"this",
"lifecycle",
"monitor",
"notify",
"all",
"(",
")",
";",
"}",
"/",
"/",
"stop",
"shared",
"connection",
"early",
",",
"if",
"necessary",
"if",
"(",
"was",
"running",
"&",
"&",
"shared",
"connection",
"enabled",
"(",
")",
")",
"{",
"try",
"{",
"stop",
"shared",
"connection",
"(",
")",
";",
"}",
"catch",
"(",
"throwable",
"ex",
")",
"{",
"logger",
"debug",
"(",
"\"",
"could",
"not",
"stop",
"jms",
"connection",
"on",
"shutdown",
"\"",
",",
"ex",
")",
";",
"}",
"}",
"/",
"/",
"shut",
"down",
"the",
"invokers",
"try",
"{",
"do",
"shutdown",
"(",
")",
";",
"}",
"catch",
"(",
"j",
"m",
"s",
"exception",
"ex",
")",
"{",
"throw",
"convert",
"jms",
"access",
"exception",
"(",
"ex",
")",
";",
"}",
"finally",
"{",
"if",
"(",
"shared",
"connection",
"enabled",
"(",
")",
")",
"{",
"synchronized",
"(",
"this",
"shared",
"connection",
"monitor",
")",
"{",
"connection",
"factory",
"utils",
"release",
"connection",
"(",
"this",
"shared",
"connection",
",",
"get",
"connection",
"factory",
"(",
")",
",",
"false",
")",
";",
"this",
"shared",
"connection",
"=",
"null",
";",
"}",
"}",
"}",
"}"
]
|
[
"copies",
"the",
"state",
"of",
"{",
"@",
"code",
"this",
"}",
"into",
"{",
"@",
"code",
"other",
"}"
]
| [
"public",
"void",
"copy",
"state",
"to",
"(",
"hikari",
"config",
"other",
")",
"{",
"for",
"(",
"field",
"field",
":",
"hikari",
"config",
"class",
"get",
"declared",
"fields",
"(",
")",
")",
"{",
"if",
"(",
"!",
"modifier",
"is",
"final",
"(",
"field",
"get",
"modifiers",
"(",
")",
")",
")",
"{",
"field",
"set",
"accessible",
"(",
"true",
")",
";",
"try",
"{",
"field",
"set",
"(",
"other",
",",
"field",
"get",
"(",
"this",
")",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"failed",
"to",
"copy",
"hikari",
"config",
"state",
":",
"\"",
"+",
"e",
"get",
"message",
"(",
")",
",",
"e",
")",
";",
"}",
"}",
"}",
"other",
"sealed",
"=",
"false",
";",
"}"
]
|
[
"returns",
"the",
"{",
"@",
"code",
"int",
"}",
"value",
"of",
"a",
"header",
"with",
"the",
"specified",
"{",
"@",
"code",
"name",
"}",
"and",
"removes",
"the",
"header",
"from",
"this",
"object",
"if",
"there",
"is",
"more",
"than",
"one",
"value",
"for",
"the",
"specified",
"name",
",",
"the",
"first",
"value",
"in",
"insertion",
"order",
"is",
"returned",
"in",
"any",
"case",
"all",
"values",
"for",
"{",
"@",
"code",
"name",
"}",
"are",
"removed",
"if",
"an",
"exception",
"occurs",
"during",
"the",
"translation",
"from",
"type",
"{",
"@",
"code",
"t",
"}",
"all",
"entries",
"with",
"{",
"@",
"code",
"name",
"}",
"may",
"still",
"be",
"removed"
]
| [
"int",
"get",
"int",
"and",
"remove",
"(",
"k",
"name",
",",
"int",
"default",
"value",
")",
";"
]
|
[
"write",
"the",
"entry",
"name",
"to",
"the",
"xml",
"file"
]
| [
"public",
"void",
"write",
"(",
"string",
"entry",
"name",
")",
"throws",
"i",
"o",
"exception",
"{",
"writer",
"println",
"(",
"\"",
"<",
"file",
"path",
"=",
"\\",
"\"",
"\"",
"+",
"entry",
"name",
"+",
"\"",
"\\",
"\"",
">",
"\"",
")",
";",
"writer",
"println",
"(",
"\"",
"<",
"key",
">",
"<",
"/",
"key",
">",
"\"",
")",
";",
"writer",
"println",
"(",
"\"",
"<",
"iv",
">",
"<",
"/",
"iv",
">",
"\"",
")",
";",
"writer",
"println",
"(",
"\"",
"<",
"/",
"file",
">",
"\"",
")",
";",
"}"
]
|
[
"if",
"an",
"agent",
"fails",
"in",
"the",
"middle",
"of",
"a",
"task",
"and",
"comes",
"back",
"up",
"when",
"the",
"task",
"is",
"considered",
"expired",
",",
"we",
"want",
"the",
"task",
"to",
"be",
"marked",
"as",
"done",
"and",
"not",
"re",
"-",
"sent",
"should",
"a",
"second",
"failure",
"happen"
]
| [
"public",
"void",
"test",
"agent",
"failure",
"and",
"task",
"expiry",
"(",
")",
"throws",
"exception",
"{",
"mock",
"time",
"time",
"=",
"new",
"mock",
"time",
"(",
"0",
",",
"0",
",",
"0",
")",
";",
"scheduler",
"scheduler",
"=",
"new",
"mock",
"scheduler",
"(",
"time",
")",
";",
"try",
"(",
"mini",
"trogdor",
"cluster",
"cluster",
"=",
"new",
"mini",
"trogdor",
"cluster",
"builder",
"(",
")",
"add",
"coordinator",
"(",
"\"",
"node",
"0",
"1",
"\"",
")",
"add",
"agent",
"(",
"\"",
"node",
"0",
"2",
"\"",
")",
"scheduler",
"(",
"scheduler",
")",
"build",
"(",
")",
")",
"{",
"coordinator",
"client",
"coordinator",
"client",
"=",
"cluster",
"coordinator",
"client",
"(",
")",
";",
"no",
"op",
"task",
"spec",
"foo",
"spec",
"=",
"new",
"no",
"op",
"task",
"spec",
"(",
"1",
",",
"500",
")",
";",
"coordinator",
"client",
"create",
"task",
"(",
"new",
"create",
"task",
"request",
"(",
"\"",
"foo",
"\"",
",",
"foo",
"spec",
")",
")",
";",
"task",
"state",
"expected",
"state",
"=",
"new",
"expected",
"task",
"builder",
"(",
"\"",
"foo",
"\"",
")",
"task",
"state",
"(",
"new",
"task",
"pending",
"(",
"foo",
"spec",
")",
")",
"build",
"(",
")",
"task",
"state",
"(",
")",
";",
"task",
"state",
"resp",
"=",
"coordinator",
"client",
"task",
"(",
"new",
"task",
"request",
"(",
"\"",
"foo",
"\"",
")",
")",
";",
"assert",
"equals",
"(",
"expected",
"state",
",",
"resp",
")",
";",
"time",
"sleep",
"(",
"2",
")",
";",
"new",
"expected",
"tasks",
"(",
")",
"add",
"task",
"(",
"new",
"expected",
"task",
"builder",
"(",
"\"",
"foo",
"\"",
")",
"task",
"state",
"(",
"new",
"task",
"running",
"(",
"foo",
"spec",
",",
"2",
",",
"new",
"text",
"node",
"(",
"\"",
"active",
"\"",
")",
")",
")",
"worker",
"state",
"(",
"new",
"worker",
"running",
"(",
"\"",
"foo",
"\"",
",",
"foo",
"spec",
",",
"2",
",",
"new",
"text",
"node",
"(",
"\"",
"active",
"\"",
")",
")",
")",
"build",
"(",
")",
")",
"wait",
"for",
"(",
"coordinator",
"client",
")",
"wait",
"for",
"(",
"cluster",
"agent",
"client",
"(",
"\"",
"node",
"0",
"2",
"\"",
")",
")",
";",
"cluster",
"restart",
"agent",
"(",
"\"",
"node",
"0",
"2",
"\"",
")",
";",
"time",
"sleep",
"(",
"550",
")",
";",
"/",
"/",
"coordinator",
"heartbeat",
"sees",
"that",
"the",
"agent",
"is",
"back",
"up",
",",
"re",
"-",
"schedules",
"the",
"task",
"but",
"the",
"agent",
"expires",
"it",
"new",
"expected",
"tasks",
"(",
")",
"add",
"task",
"(",
"new",
"expected",
"task",
"builder",
"(",
"\"",
"foo",
"\"",
")",
"task",
"state",
"(",
"new",
"task",
"done",
"(",
"foo",
"spec",
",",
"2",
",",
"552",
",",
"\"",
"worker",
"expired",
"\"",
",",
"false",
",",
"null",
")",
")",
"worker",
"state",
"(",
"new",
"worker",
"done",
"(",
"\"",
"foo",
"\"",
",",
"foo",
"spec",
",",
"552",
",",
"552",
",",
"null",
",",
"\"",
"worker",
"expired",
"\"",
")",
")",
"build",
"(",
")",
")",
"wait",
"for",
"(",
"coordinator",
"client",
")",
"wait",
"for",
"(",
"cluster",
"agent",
"client",
"(",
"\"",
"node",
"0",
"2",
"\"",
")",
")",
";",
"cluster",
"restart",
"agent",
"(",
"\"",
"node",
"0",
"2",
"\"",
")",
";",
"/",
"/",
"coordinator",
"heartbeat",
"sees",
"that",
"the",
"agent",
"is",
"back",
"up",
"but",
"does",
"not",
"re",
"-",
"schedule",
"the",
"task",
"as",
"it",
"is",
"done",
"new",
"expected",
"tasks",
"(",
")",
"add",
"task",
"(",
"new",
"expected",
"task",
"builder",
"(",
"\"",
"foo",
"\"",
")",
"task",
"state",
"(",
"new",
"task",
"done",
"(",
"foo",
"spec",
",",
"2",
",",
"552",
",",
"\"",
"worker",
"expired",
"\"",
",",
"false",
",",
"null",
")",
")",
"/",
"/",
"no",
"worker",
"states",
"build",
"(",
")",
")",
"wait",
"for",
"(",
"coordinator",
"client",
")",
"wait",
"for",
"(",
"cluster",
"agent",
"client",
"(",
"\"",
"node",
"0",
"2",
"\"",
")",
")",
";",
"}",
"}"
]
|
[
"bind",
"the",
"given",
"simp",
"attributes",
"to",
"the",
"current",
"thread"
]
| [
"public",
"static",
"void",
"set",
"attributes",
"(",
"@",
"nullable",
"simp",
"attributes",
"attributes",
")",
"{",
"if",
"(",
"attributes",
"!",
"=",
"null",
")",
"{",
"attributes",
"holder",
"set",
"(",
"attributes",
")",
";",
"}",
"else",
"{",
"reset",
"attributes",
"(",
")",
";",
"}",
"}"
]
|
[
"get",
"the",
"list",
"of",
"all",
"contacts",
"attached",
"to",
"this",
"body",
"@",
"warning",
"this",
"list",
"changes",
"during",
"the",
"time",
"step",
"and",
"you",
"may",
"miss",
"some",
"collisions",
"if",
"you",
"don",
"'",
"t",
"use",
"contact",
"listener"
]
| [
"public",
"final",
"contact",
"edge",
"get",
"contact",
"list",
"(",
")",
"{",
"return",
"m",
"contact",
"list",
";",
"}"
]
|
[
"read",
"the",
"given",
"{",
"@",
"link",
"bean",
"method",
"}",
",",
"registering",
"bean",
"definitions",
"with",
"the",
"bean",
"definition",
"registry",
"based",
"on",
"its",
"contents"
]
| [
"private",
"void",
"load",
"bean",
"definitions",
"for",
"bean",
"method",
"(",
"bean",
"method",
"bean",
"method",
")",
"{",
"configuration",
"class",
"config",
"class",
"=",
"bean",
"method",
"get",
"configuration",
"class",
"(",
")",
";",
"method",
"metadata",
"metadata",
"=",
"bean",
"method",
"get",
"metadata",
"(",
")",
";",
"string",
"method",
"name",
"=",
"metadata",
"get",
"method",
"name",
"(",
")",
";",
"/",
"/",
"do",
"we",
"need",
"to",
"mark",
"the",
"bean",
"as",
"skipped",
"by",
"its",
"condition",
"?",
"if",
"(",
"this",
"condition",
"evaluator",
"should",
"skip",
"(",
"metadata",
",",
"configuration",
"phase",
"register",
"bean",
")",
")",
"{",
"config",
"class",
"skipped",
"bean",
"methods",
"add",
"(",
"method",
"name",
")",
";",
"return",
";",
"}",
"if",
"(",
"config",
"class",
"skipped",
"bean",
"methods",
"contains",
"(",
"method",
"name",
")",
")",
"{",
"return",
";",
"}",
"annotation",
"attributes",
"bean",
"=",
"annotation",
"config",
"utils",
"attributes",
"for",
"(",
"metadata",
",",
"bean",
"class",
")",
";",
"assert",
"state",
"(",
"bean",
"!",
"=",
"null",
",",
"\"",
"no",
"@",
"bean",
"annotation",
"attributes",
"\"",
")",
";",
"/",
"/",
"consider",
"name",
"and",
"any",
"aliases",
"list",
"<",
"string",
">",
"names",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"arrays",
"as",
"list",
"(",
"bean",
"get",
"string",
"array",
"(",
"\"",
"name",
"\"",
")",
")",
")",
";",
"string",
"bean",
"name",
"=",
"(",
"!",
"names",
"is",
"empty",
"(",
")",
"?",
"names",
"remove",
"(",
"0",
")",
":",
"method",
"name",
")",
";",
"/",
"/",
"register",
"aliases",
"even",
"when",
"overridden",
"for",
"(",
"string",
"alias",
":",
"names",
")",
"{",
"this",
"registry",
"register",
"alias",
"(",
"bean",
"name",
",",
"alias",
")",
";",
"}",
"/",
"/",
"has",
"this",
"effectively",
"been",
"overridden",
"before",
"(",
"e",
"g",
"via",
"xml",
")",
"?",
"if",
"(",
"is",
"overridden",
"by",
"existing",
"definition",
"(",
"bean",
"method",
",",
"bean",
"name",
")",
")",
"{",
"if",
"(",
"bean",
"name",
"equals",
"(",
"bean",
"method",
"get",
"configuration",
"class",
"(",
")",
"get",
"bean",
"name",
"(",
")",
")",
")",
"{",
"throw",
"new",
"bean",
"definition",
"store",
"exception",
"(",
"bean",
"method",
"get",
"configuration",
"class",
"(",
")",
"get",
"resource",
"(",
")",
"get",
"description",
"(",
")",
",",
"bean",
"name",
",",
"\"",
"bean",
"name",
"derived",
"from",
"@",
"bean",
"method",
"'",
"\"",
"+",
"bean",
"method",
"get",
"metadata",
"(",
")",
"get",
"method",
"name",
"(",
")",
"+",
"\"",
"'",
"clashes",
"with",
"bean",
"name",
"for",
"containing",
"configuration",
"class",
";",
"please",
"make",
"those",
"names",
"unique",
"!",
"\"",
")",
";",
"}",
"return",
";",
"}",
"configuration",
"class",
"bean",
"definition",
"bean",
"def",
"=",
"new",
"configuration",
"class",
"bean",
"definition",
"(",
"config",
"class",
",",
"metadata",
",",
"bean",
"name",
")",
";",
"bean",
"def",
"set",
"source",
"(",
"this",
"source",
"extractor",
"extract",
"source",
"(",
"metadata",
",",
"config",
"class",
"get",
"resource",
"(",
")",
")",
")",
";",
"if",
"(",
"metadata",
"is",
"static",
"(",
")",
")",
"{",
"/",
"/",
"static",
"@",
"bean",
"method",
"if",
"(",
"config",
"class",
"get",
"metadata",
"(",
")",
"instanceof",
"standard",
"annotation",
"metadata",
")",
"{",
"bean",
"def",
"set",
"bean",
"class",
"(",
"(",
"(",
"standard",
"annotation",
"metadata",
")",
"config",
"class",
"get",
"metadata",
"(",
")",
")",
"get",
"introspected",
"class",
"(",
")",
")",
";",
"}",
"else",
"{",
"bean",
"def",
"set",
"bean",
"class",
"name",
"(",
"config",
"class",
"get",
"metadata",
"(",
")",
"get",
"class",
"name",
"(",
")",
")",
";",
"}",
"bean",
"def",
"set",
"unique",
"factory",
"method",
"name",
"(",
"method",
"name",
")",
";",
"}",
"else",
"{",
"/",
"/",
"instance",
"@",
"bean",
"method",
"bean",
"def",
"set",
"factory",
"bean",
"name",
"(",
"config",
"class",
"get",
"bean",
"name",
"(",
")",
")",
";",
"bean",
"def",
"set",
"unique",
"factory",
"method",
"name",
"(",
"method",
"name",
")",
";",
"}",
"if",
"(",
"metadata",
"instanceof",
"standard",
"method",
"metadata",
")",
"{",
"bean",
"def",
"set",
"resolved",
"factory",
"method",
"(",
"(",
"(",
"standard",
"method",
"metadata",
")",
"metadata",
")",
"get",
"introspected",
"method",
"(",
")",
")",
";",
"}",
"bean",
"def",
"set",
"autowire",
"mode",
"(",
"abstract",
"bean",
"definition",
"autowire",
"constructor",
")",
";",
"bean",
"def",
"set",
"attribute",
"(",
"org",
"springframework",
"beans",
"factory",
"annotation",
"required",
"annotation",
"bean",
"post",
"processor",
"skip",
"required",
"check",
"attribute",
",",
"boolean",
"true",
")",
";",
"annotation",
"config",
"utils",
"process",
"common",
"definition",
"annotations",
"(",
"bean",
"def",
",",
"metadata",
")",
";",
"autowire",
"autowire",
"=",
"bean",
"get",
"enum",
"(",
"\"",
"autowire",
"\"",
")",
";",
"if",
"(",
"autowire",
"is",
"autowire",
"(",
")",
")",
"{",
"bean",
"def",
"set",
"autowire",
"mode",
"(",
"autowire",
"value",
"(",
")",
")",
";",
"}",
"boolean",
"autowire",
"candidate",
"=",
"bean",
"get",
"boolean",
"(",
"\"",
"autowire",
"candidate",
"\"",
")",
";",
"if",
"(",
"!",
"autowire",
"candidate",
")",
"{",
"bean",
"def",
"set",
"autowire",
"candidate",
"(",
"false",
")",
";",
"}",
"string",
"init",
"method",
"name",
"=",
"bean",
"get",
"string",
"(",
"\"",
"init",
"method",
"\"",
")",
";",
"if",
"(",
"string",
"utils",
"has",
"text",
"(",
"init",
"method",
"name",
")",
")",
"{",
"bean",
"def",
"set",
"init",
"method",
"name",
"(",
"init",
"method",
"name",
")",
";",
"}",
"string",
"destroy",
"method",
"name",
"=",
"bean",
"get",
"string",
"(",
"\"",
"destroy",
"method",
"\"",
")",
";",
"bean",
"def",
"set",
"destroy",
"method",
"name",
"(",
"destroy",
"method",
"name",
")",
";",
"/",
"/",
"consider",
"scoping",
"scoped",
"proxy",
"mode",
"proxy",
"mode",
"=",
"scoped",
"proxy",
"mode",
"no",
";",
"annotation",
"attributes",
"attributes",
"=",
"annotation",
"config",
"utils",
"attributes",
"for",
"(",
"metadata",
",",
"scope",
"class",
")",
";",
"if",
"(",
"attributes",
"!",
"=",
"null",
")",
"{",
"bean",
"def",
"set",
"scope",
"(",
"attributes",
"get",
"string",
"(",
"\"",
"value",
"\"",
")",
")",
";",
"proxy",
"mode",
"=",
"attributes",
"get",
"enum",
"(",
"\"",
"proxy",
"mode",
"\"",
")",
";",
"if",
"(",
"proxy",
"mode",
"=",
"=",
"scoped",
"proxy",
"mode",
"default",
")",
"{",
"proxy",
"mode",
"=",
"scoped",
"proxy",
"mode",
"no",
";",
"}",
"}",
"/",
"/",
"replace",
"the",
"original",
"bean",
"definition",
"with",
"the",
"target",
"one",
",",
"if",
"necessary",
"bean",
"definition",
"bean",
"def",
"to",
"register",
"=",
"bean",
"def",
";",
"if",
"(",
"proxy",
"mode",
"!",
"=",
"scoped",
"proxy",
"mode",
"no",
")",
"{",
"bean",
"definition",
"holder",
"proxy",
"def",
"=",
"scoped",
"proxy",
"creator",
"create",
"scoped",
"proxy",
"(",
"new",
"bean",
"definition",
"holder",
"(",
"bean",
"def",
",",
"bean",
"name",
")",
",",
"this",
"registry",
",",
"proxy",
"mode",
"=",
"=",
"scoped",
"proxy",
"mode",
"target",
"class",
")",
";",
"bean",
"def",
"to",
"register",
"=",
"new",
"configuration",
"class",
"bean",
"definition",
"(",
"(",
"root",
"bean",
"definition",
")",
"proxy",
"def",
"get",
"bean",
"definition",
"(",
")",
",",
"config",
"class",
",",
"metadata",
",",
"bean",
"name",
")",
";",
"}",
"if",
"(",
"logger",
"is",
"trace",
"enabled",
"(",
")",
")",
"{",
"logger",
"trace",
"(",
"string",
"format",
"(",
"\"",
"registering",
"bean",
"definition",
"for",
"@",
"bean",
"method",
"%",
"s",
"%",
"s",
"(",
")",
"\"",
",",
"config",
"class",
"get",
"metadata",
"(",
")",
"get",
"class",
"name",
"(",
")",
",",
"bean",
"name",
")",
")",
";",
"}",
"this",
"registry",
"register",
"bean",
"definition",
"(",
"bean",
"name",
",",
"bean",
"def",
"to",
"register",
")",
";",
"}"
]
|
[
"get",
"photo",
"urls"
]
| [
"public",
"set",
"<",
"string",
">",
"get",
"photo",
"urls",
"(",
")",
"{",
"return",
"photo",
"urls",
";",
"}"
]
|
[
"should",
"speculative",
"execution",
"be",
"used",
"for",
"this",
"job",
"for",
"map",
"tasks",
"?",
"defaults",
"to",
"<",
"code",
">",
"true",
"<",
"code",
">"
]
| [
"public",
"boolean",
"get",
"map",
"speculative",
"execution",
"(",
")",
"{",
"return",
"get",
"boolean",
"(",
"job",
"context",
"map",
"speculative",
",",
"true",
")",
";",
"}"
]
|
[
"tests",
"expected",
"values",
"of",
"{",
"@",
"link",
"com",
"google",
"devtools",
"build",
"lib",
"rules",
"android",
"android",
"rule",
"classes",
"multidex",
"mode",
"}"
]
| [
"public",
"void",
"test",
"multidex",
"mode",
"enum",
"(",
")",
"throws",
"exception",
"{",
"assert",
"that",
"(",
"multidex",
"mode",
"get",
"valid",
"values",
"(",
")",
")",
"contains",
"exactly",
"(",
"\"",
"native",
"\"",
",",
"\"",
"legacy",
"\"",
",",
"\"",
"manual",
"main",
"dex",
"\"",
",",
"\"",
"off",
"\"",
")",
";",
"assert",
"that",
"(",
"multidex",
"mode",
"from",
"value",
"(",
"\"",
"native",
"\"",
")",
")",
"is",
"same",
"instance",
"as",
"(",
"multidex",
"mode",
"native",
")",
";",
"assert",
"that",
"(",
"multidex",
"mode",
"native",
"get",
"attribute",
"value",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"\"",
"native",
"\"",
")",
";",
"assert",
"that",
"(",
"multidex",
"mode",
"from",
"value",
"(",
"\"",
"legacy",
"\"",
")",
")",
"is",
"same",
"instance",
"as",
"(",
"multidex",
"mode",
"legacy",
")",
";",
"assert",
"that",
"(",
"multidex",
"mode",
"legacy",
"get",
"attribute",
"value",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"\"",
"legacy",
"\"",
")",
";",
"assert",
"that",
"(",
"multidex",
"mode",
"from",
"value",
"(",
"\"",
"manual",
"main",
"dex",
"\"",
")",
")",
"is",
"same",
"instance",
"as",
"(",
"multidex",
"mode",
"manual",
"main",
"dex",
")",
";",
"assert",
"that",
"(",
"multidex",
"mode",
"manual",
"main",
"dex",
"get",
"attribute",
"value",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"\"",
"manual",
"main",
"dex",
"\"",
")",
";",
"assert",
"that",
"(",
"multidex",
"mode",
"from",
"value",
"(",
"\"",
"off",
"\"",
")",
")",
"is",
"same",
"instance",
"as",
"(",
"multidex",
"mode",
"off",
")",
";",
"assert",
"that",
"(",
"multidex",
"mode",
"off",
"get",
"attribute",
"value",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"\"",
"off",
"\"",
")",
";",
"}"
]
|
[
"create",
"a",
"new",
"{",
"@",
"code",
"web",
"client",
"}",
"with",
"reactor",
"netty",
"by",
"default"
]
| [
"static",
"web",
"client",
"create",
"(",
")",
"{",
"return",
"new",
"default",
"web",
"client",
"builder",
"(",
")",
"build",
"(",
")",
";",
"}"
]
|
[
"test",
"that",
"program",
"diff",
"can",
"determine",
"the",
"function",
"bodies",
"are",
"different"
]
| [
"public",
"void",
"test",
"function",
"body",
"diff",
"(",
")",
"throws",
"exception",
"{",
"int",
"transaction",
"i",
"d",
"=",
"p",
"2",
"start",
"transaction",
"(",
"\"",
"test",
"transaction",
"\"",
")",
";",
"function",
"function",
"2",
"=",
"p",
"2",
"get",
"function",
"manager",
"(",
")",
"get",
"function",
"at",
"(",
"addr",
"(",
"0x",
"1",
"0",
"0",
"2",
"9",
"9e",
")",
")",
";",
"function",
"2",
"set",
"body",
"(",
"new",
"address",
"set",
"(",
"addr",
"(",
"0x",
"1",
"0",
"0",
"2",
"9",
"9e",
")",
",",
"addr",
"(",
"0x",
"1",
"0",
"0",
"2a",
"8",
"9",
")",
")",
")",
";",
"p",
"2",
"end",
"transaction",
"(",
"transaction",
"i",
"d",
",",
"true",
")",
";",
"program",
"diff",
"=",
"new",
"program",
"diff",
"(",
"p",
"1",
",",
"p",
"2",
")",
";",
"program",
"diff",
"set",
"filter",
"(",
"new",
"program",
"diff",
"filter",
"(",
"program",
"diff",
"filter",
"function",
"diffs",
")",
")",
";",
"address",
"set",
"as",
"=",
"new",
"address",
"set",
"(",
")",
";",
"as",
"add",
"range",
"(",
"addr",
"(",
"0x",
"0",
"1",
"0",
"0",
"2",
"9",
"9e",
")",
",",
"addr",
"(",
"0x",
"0",
"1",
"0",
"0",
"2",
"9",
"9e",
")",
")",
";",
"assert",
"equals",
"(",
"as",
",",
"program",
"diff",
"get",
"differences",
"(",
"program",
"diff",
"get",
"filter",
"(",
")",
",",
"null",
")",
")",
";",
"}"
]
|
[
"removes",
"the",
"interest",
"ops",
"from",
"selection",
"key"
]
| [
"public",
"void",
"remove",
"interest",
"ops",
"(",
"int",
"ops",
")",
"{",
"key",
"interest",
"ops",
"(",
"key",
"interest",
"ops",
"(",
")",
"&",
"~",
"ops",
")",
";",
"}"
]
|
[
"col",
"attributes",
"affect",
"n",
"columns",
"default",
":",
"1"
]
| [
"col",
"$",
"span",
"(",
"int",
"cols",
")",
";",
"/",
"/",
"$",
"width",
"omitted",
"use",
"css",
"instead"
]
|
[
"returns",
"the",
"sum",
"of",
"the",
"values",
"<",
"h",
"3",
">",
"non",
"-",
"finite",
"values",
"<",
"h",
"3",
">",
"if",
"the",
"dataset",
"contains",
"{",
"@",
"link",
"double",
"#",
"na",
"n",
"}",
"then",
"the",
"result",
"is",
"{",
"@",
"link",
"double",
"#",
"na",
"n",
"}",
"if",
"it",
"contains",
"both",
"{",
"@",
"link",
"double",
"#",
"positive",
"infinity",
"}",
"and",
"{",
"@",
"link",
"double",
"#",
"negative",
"infinity",
"}",
"then",
"the",
"result",
"is",
"{",
"@",
"link",
"double",
"#",
"na",
"n",
"}",
"if",
"it",
"contains",
"{",
"@",
"link",
"double",
"#",
"positive",
"infinity",
"}",
"and",
"finite",
"values",
"only",
"or",
"{",
"@",
"link",
"double",
"#",
"positive",
"infinity",
"}",
"only",
",",
"the",
"result",
"is",
"{",
"@",
"link",
"double",
"#",
"positive",
"infinity",
"}",
"if",
"it",
"contains",
"{",
"@",
"link",
"double",
"#",
"negative",
"infinity",
"}",
"and",
"finite",
"values",
"only",
"or",
"{",
"@",
"link",
"double",
"#",
"negative",
"infinity",
"}",
"only",
",",
"the",
"result",
"is",
"{",
"@",
"link",
"double",
"#",
"negative",
"infinity",
"}"
]
| [
"public",
"final",
"double",
"sum",
"(",
")",
"{",
"return",
"mean",
"*",
"count",
";",
"}"
]
|
[
"sets",
"if",
"delegation",
"token",
"should",
"be",
"transmitted",
"in",
"the",
"url",
"query",
"string",
"by",
"default",
"it",
"is",
"transmitted",
"using",
"the",
"{",
"@",
"link",
"delegation",
"token",
"authenticator",
"#",
"delegation",
"token",
"header",
"}",
"http",
"header",
"this",
"method",
"is",
"provided",
"to",
"enable",
"web",
"h",
"d",
"f",
"s",
"backwards",
"compatibility"
]
| [
"protected",
"void",
"set",
"use",
"query",
"string",
"for",
"delegation",
"token",
"(",
"boolean",
"use",
"query",
"string",
")",
"{",
"use",
"query",
"stringfor",
"delegation",
"token",
"=",
"use",
"query",
"string",
";",
"}"
]
|
[
"configure",
"ssl",
"and",
"post",
"request",
"parameters"
]
| [
"private",
"void",
"post",
"it",
"(",
"https",
"u",
"r",
"l",
"connection",
"conn",
")",
"throws",
"exception",
"{",
"final",
"s",
"s",
"l",
"context",
"ssl",
"ctx",
"=",
"s",
"s",
"l",
"context",
"get",
"instance",
"(",
"\"",
"tls",
"\"",
")",
";",
"ssl",
"ctx",
"init",
"(",
"null",
",",
"new",
"trust",
"manager",
"[",
"]",
"{",
"trust",
"all",
"}",
",",
"null",
")",
";",
"conn",
"set",
"hostname",
"verifier",
"(",
"new",
"noop",
"hostname",
"verifier",
"(",
")",
")",
";",
"conn",
"set",
"s",
"s",
"l",
"socket",
"factory",
"(",
"ssl",
"ctx",
"get",
"socket",
"factory",
"(",
")",
")",
";",
"/",
"/",
"make",
"it",
"a",
"post",
"conn",
"set",
"do",
"output",
"(",
"true",
")",
";",
"conn",
"get",
"output",
"stream",
"(",
")",
"write",
"(",
"new",
"byte",
"[",
"]",
"{",
"}",
")",
";",
"}"
]
|
[
"range",
"-",
"partitions",
"a",
"data",
"set",
"on",
"the",
"specified",
"tuple",
"field",
"positions"
]
| [
"public",
"static",
"<",
"t",
">",
"partition",
"operator",
"<",
"t",
">",
"partition",
"by",
"range",
"(",
"data",
"set",
"<",
"t",
">",
"input",
",",
"data",
"distribution",
"distribution",
",",
"int",
"fields",
")",
"{",
"return",
"new",
"partition",
"operator",
"<",
">",
"(",
"input",
",",
"partition",
"operator",
"base",
"partition",
"method",
"range",
",",
"new",
"keys",
"expression",
"keys",
"<",
">",
"(",
"fields",
",",
"input",
"get",
"type",
"(",
")",
",",
"false",
")",
",",
"distribution",
",",
"utils",
"get",
"call",
"location",
"name",
"(",
")",
")",
";",
"}"
]
|
[
"adds",
"an",
"{",
"@",
"link",
"index",
"request",
"}",
"to",
"the",
"list",
"of",
"actions",
"to",
"execute",
"follows",
"the",
"same",
"behavior",
"of",
"{",
"@",
"link",
"index",
"request",
"}",
"(",
"for",
"example",
",",
"if",
"no",
"id",
"is",
"provided",
",",
"one",
"will",
"be",
"generated",
",",
"or",
"usage",
"of",
"the",
"create",
"flag",
")"
]
| [
"public",
"bulk",
"processor",
"add",
"(",
"index",
"request",
"request",
")",
"{",
"return",
"add",
"(",
"(",
"doc",
"write",
"request",
"<",
"?",
">",
")",
"request",
")",
";",
"}"
]
|
[
"converts",
"the",
"given",
"{",
"@",
"link",
"data",
"stream",
"}",
"into",
"a",
"{",
"@",
"link",
"table",
"}",
"with",
"specified",
"field",
"names",
"there",
"are",
"two",
"modes",
"for",
"mapping",
"original",
"fields",
"to",
"the",
"fields",
"of",
"the",
"{",
"@",
"link",
"table",
"}",
":",
"1",
"reference",
"input",
"fields",
"by",
"name",
":",
"all",
"fields",
"in",
"the",
"schema",
"definition",
"are",
"referenced",
"by",
"name",
"(",
"and",
"possibly",
"renamed",
"using",
"an",
"alias",
"(",
"as",
")",
"moreover",
",",
"we",
"can",
"define",
"proctime",
"and",
"rowtime",
"attributes",
"at",
"arbitrary",
"positions",
"using",
"arbitrary",
"names",
"(",
"except",
"those",
"that",
"exist",
"in",
"the",
"result",
"schema",
")",
"in",
"this",
"mode",
",",
"fields",
"can",
"be",
"reordered",
"and",
"projected",
"out",
"this",
"mode",
"can",
"be",
"used",
"for",
"any",
"input",
"type",
",",
"including",
"p",
"o",
"j",
"os",
"example",
":",
"{",
"@",
"code",
"data",
"stream",
"<",
"tuple",
"2",
"<",
"string",
",",
"long",
">",
">",
"stream",
"=",
"table",
"table",
"=",
"table",
"env",
"from",
"data",
"stream",
"(",
"stream",
",",
"$",
"(",
"\"",
"f",
"1",
"\"",
")",
",",
"reorder",
"and",
"use",
"the",
"original",
"field",
"$",
"(",
"\"",
"rowtime",
"\"",
")",
"rowtime",
"(",
")",
",",
"extract",
"the",
"internally",
"attached",
"timestamp",
"into",
"an",
"event",
"-",
"time",
"attribute",
"named",
"'",
"rowtime",
"'",
"$",
"(",
"\"",
"f",
"0",
"\"",
")",
"as",
"(",
"\"",
"name",
"\"",
")",
"reorder",
"and",
"give",
"the",
"original",
"field",
"a",
"better",
"name",
")",
";",
"}",
"2",
"reference",
"input",
"fields",
"by",
"position",
":",
"in",
"this",
"mode",
",",
"fields",
"are",
"simply",
"renamed",
"event",
"-",
"time",
"attributes",
"can",
"replace",
"the",
"field",
"on",
"their",
"position",
"in",
"the",
"input",
"data",
"(",
"if",
"it",
"is",
"of",
"correct",
"type",
")",
"or",
"be",
"appended",
"at",
"the",
"end",
"proctime",
"attributes",
"must",
"be",
"appended",
"at",
"the",
"end",
"this",
"mode",
"can",
"only",
"be",
"used",
"if",
"the",
"input",
"type",
"has",
"a",
"defined",
"field",
"order",
"(",
"tuple",
",",
"case",
"class",
",",
"row",
")",
"and",
"none",
"of",
"the",
"{",
"@",
"code",
"fields",
"}",
"references",
"a",
"field",
"of",
"the",
"input",
"type",
"example",
":",
"{",
"@",
"code",
"data",
"stream",
"<",
"tuple",
"2",
"<",
"string",
",",
"long",
">",
">",
"stream",
"=",
"table",
"table",
"=",
"table",
"env",
"from",
"data",
"stream",
"(",
"stream",
",",
"$",
"(",
"\"",
"a",
"\"",
")",
",",
"rename",
"the",
"first",
"field",
"to",
"'",
"a",
"'",
"$",
"(",
"\"",
"b",
"\"",
")",
",",
"rename",
"the",
"second",
"field",
"to",
"'",
"b",
"'",
"$",
"(",
"\"",
"rowtime",
"\"",
")",
"rowtime",
"(",
")",
"extract",
"the",
"internally",
"attached",
"timestamp",
"into",
"an",
"event",
"-",
"time",
"attribute",
"named",
"'",
"rowtime",
"'",
")",
";",
"}"
]
| [
"<",
"t",
">",
"table",
"from",
"data",
"stream",
"(",
"data",
"stream",
"<",
"t",
">",
"data",
"stream",
",",
"expression",
"fields",
")",
";"
]
|
[
"adds",
"\"",
"declared",
"providers",
"\"",
"defined",
"in",
"native",
"code",
"to",
"the",
"rule",
"use",
"this",
"method",
"for",
"declared",
"providers",
"in",
"definitions",
"of",
"native",
"rules",
"use",
"{",
"@",
"link",
"#",
"add",
"starlark",
"declared",
"provider",
"(",
"info",
")",
"}",
"for",
"starlark",
"rule",
"implementations"
]
| [
"public",
"rule",
"configured",
"target",
"builder",
"add",
"native",
"declared",
"providers",
"(",
"iterable",
"<",
"info",
">",
"providers",
")",
"{",
"for",
"(",
"info",
"provider",
":",
"providers",
")",
"{",
"add",
"native",
"declared",
"provider",
"(",
"provider",
")",
";",
"}",
"return",
"this",
";",
"}"
]
|
[
"required",
"spring",
"injected",
"{",
"@",
"link",
"spring",
"rejected",
"jobs",
"handler",
"}",
"implementation",
"that",
"will",
"be",
"used",
"when",
"jobs",
"were",
"rejected",
"by",
"the",
"task",
"executor"
]
| [
"public",
"void",
"set",
"rejected",
"jobs",
"handler",
"(",
"spring",
"rejected",
"jobs",
"handler",
"rejected",
"jobs",
"handler",
")",
"{",
"this",
"rejected",
"jobs",
"handler",
"=",
"rejected",
"jobs",
"handler",
";",
"}"
]
|
[
"return",
"the",
"compressed",
"bitmap",
"using",
"scale"
]
| [
"public",
"static",
"bitmap",
"compress",
"by",
"scale",
"(",
"final",
"bitmap",
"src",
",",
"final",
"int",
"new",
"width",
",",
"final",
"int",
"new",
"height",
",",
"final",
"boolean",
"recycle",
")",
"{",
"return",
"scale",
"(",
"src",
",",
"new",
"width",
",",
"new",
"height",
",",
"recycle",
")",
";",
"}"
]
|
[
"returns",
"total",
"bytes",
"written",
"by",
"this",
"merge"
]
| [
"public",
"static",
"long",
"get",
"total",
"bytes",
"written",
"(",
"thread",
"thread",
",",
"merge",
"policy",
"one",
"merge",
"merge",
")",
"throws",
"i",
"o",
"exception",
"{"
]
|
[
"find",
"the",
"fields",
"constant",
"that",
"matches",
"field",
"id",
",",
"or",
"null",
"if",
"its",
"not",
"found"
]
| [
"public",
"static",
"fields",
"find",
"by",
"thrift",
"id",
"(",
"int",
"field",
"id",
")",
"{",
"switch",
"(",
"field",
"id",
")",
"{",
"case",
"0",
":",
"/",
"/",
"success",
"return",
"success",
";",
"default",
":",
"return",
"null",
";",
"}",
"}"
]
|
[
"skips",
"over",
"and",
"discards",
"n",
"bytes",
"of",
"data",
"from",
"this",
"input",
"stream"
]
| [
"public",
"synchronized",
"long",
"skip",
"(",
"long",
"n",
")",
"throws",
"i",
"o",
"exception",
"{",
"check",
"state",
"(",
")",
";",
"if",
"(",
"blob",
"input",
"stream",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"blob",
"input",
"stream",
"is",
"open",
";",
"delegate",
"the",
"work",
"to",
"it",
"long",
"skipped",
"=",
"blob",
"input",
"stream",
"skip",
"(",
"n",
")",
";",
"/",
"/",
"update",
"position",
"to",
"the",
"actual",
"skip",
"value",
"stream",
"position",
"+",
"=",
"skipped",
";",
"return",
"skipped",
";",
"}",
"/",
"/",
"no",
"blob",
"stream",
";",
"implement",
"the",
"skip",
"logic",
"directly",
"if",
"(",
"n",
"<",
"0",
"|",
"|",
"n",
">",
"stream",
"length",
"-",
"get",
"pos",
"(",
")",
")",
"{",
"throw",
"new",
"index",
"out",
"of",
"bounds",
"exception",
"(",
"\"",
"skip",
"range",
"\"",
")",
";",
"}",
"if",
"(",
"stream",
"buffer",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"there",
"'",
"s",
"a",
"buffer",
",",
"so",
"seek",
"with",
"it",
"if",
"(",
"n",
"<",
"stream",
"buffer",
"length",
"-",
"stream",
"buffer",
"position",
")",
"{",
"/",
"/",
"new",
"range",
"is",
"in",
"the",
"buffer",
",",
"so",
"just",
"update",
"the",
"buffer",
"position",
"/",
"/",
"skip",
"within",
"the",
"buffer",
"stream",
"buffer",
"position",
"+",
"=",
"(",
"int",
")",
"n",
";",
"}",
"else",
"{",
"/",
"/",
"skip",
"is",
"out",
"of",
"range",
",",
"so",
"move",
"position",
"to",
"ne",
"value",
"and",
"reset",
"/",
"/",
"the",
"buffer",
"ready",
"for",
"the",
"next",
"read",
"(",
")",
"stream",
"position",
"=",
"get",
"pos",
"(",
")",
"+",
"n",
";",
"reset",
"stream",
"buffer",
"(",
")",
";",
"}",
"}",
"else",
"{",
"/",
"/",
"no",
"stream",
"buffer",
";",
"increment",
"the",
"stream",
"position",
"ready",
"for",
"/",
"/",
"the",
"next",
"triggered",
"connection",
"&",
"read",
"stream",
"position",
"+",
"=",
"n",
";",
"}",
"return",
"n",
";",
"}"
]
|
[
"join",
"a",
"list",
"of",
"strings",
"with",
"the",
"given",
"separator"
]
| [
"public",
"static",
"string",
"join",
"(",
"collection",
"<",
"string",
">",
"list",
",",
"string",
"separator",
")",
"{",
"iterator",
"<",
"string",
">",
"iterator",
"=",
"list",
"iterator",
"(",
")",
";",
"string",
"builder",
"out",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"if",
"(",
"iterator",
"has",
"next",
"(",
")",
")",
"{",
"out",
"append",
"(",
"iterator",
"next",
"(",
")",
")",
";",
"}",
"while",
"(",
"iterator",
"has",
"next",
"(",
")",
")",
"{",
"out",
"append",
"(",
"separator",
")",
"append",
"(",
"iterator",
"next",
"(",
")",
")",
";",
"}",
"return",
"out",
"to",
"string",
"(",
")",
";",
"}"
]
|
[
"gets",
"whether",
"there",
"are",
"items",
"in",
"the",
"queue"
]
| [
"public",
"boolean",
"is",
"not",
"empty",
"(",
")",
"{",
"return",
"!",
"is",
"empty",
"(",
")",
";",
"}"
]
|
[
"build",
"call",
"for",
"test",
"classname"
]
| [
"public",
"okhttp",
"3",
"call",
"test",
"classname",
"call",
"(",
"client",
"body",
",",
"final",
"api",
"callback",
"callback",
")",
"throws",
"api",
"exception",
"{",
"object",
"local",
"var",
"post",
"body",
"=",
"body",
";",
"/",
"/",
"create",
"path",
"and",
"map",
"variables",
"string",
"local",
"var",
"path",
"=",
"\"",
"/",
"fake",
"classname",
"test",
"\"",
";",
"list",
"<",
"pair",
">",
"local",
"var",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"list",
"<",
"pair",
">",
"local",
"var",
"collection",
"query",
"params",
"=",
"new",
"array",
"list",
"<",
"pair",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"header",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"local",
"var",
"cookie",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"map",
"<",
"string",
",",
"object",
">",
"local",
"var",
"form",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"final",
"string",
"[",
"]",
"local",
"var",
"accepts",
"=",
"{",
"\"",
"application",
"/",
"json",
"\"",
"}",
";",
"final",
"string",
"local",
"var",
"accept",
"=",
"local",
"var",
"api",
"client",
"select",
"header",
"accept",
"(",
"local",
"var",
"accepts",
")",
";",
"if",
"(",
"local",
"var",
"accept",
"!",
"=",
"null",
")",
"{",
"local",
"var",
"header",
"params",
"put",
"(",
"\"",
"accept",
"\"",
",",
"local",
"var",
"accept",
")",
";",
"}",
"final",
"string",
"[",
"]",
"local",
"var",
"content",
"types",
"=",
"{",
"\"",
"application",
"/",
"json",
"\"",
"}",
";",
"final",
"string",
"local",
"var",
"content",
"type",
"=",
"local",
"var",
"api",
"client",
"select",
"header",
"content",
"type",
"(",
"local",
"var",
"content",
"types",
")",
";",
"local",
"var",
"header",
"params",
"put",
"(",
"\"",
"content",
"-",
"type",
"\"",
",",
"local",
"var",
"content",
"type",
")",
";",
"string",
"[",
"]",
"local",
"var",
"auth",
"names",
"=",
"new",
"string",
"[",
"]",
"{",
"\"",
"api",
"key",
"query",
"\"",
"}",
";",
"return",
"local",
"var",
"api",
"client",
"build",
"call",
"(",
"local",
"var",
"path",
",",
"\"",
"patch",
"\"",
",",
"local",
"var",
"query",
"params",
",",
"local",
"var",
"collection",
"query",
"params",
",",
"local",
"var",
"post",
"body",
",",
"local",
"var",
"header",
"params",
",",
"local",
"var",
"cookie",
"params",
",",
"local",
"var",
"form",
"params",
",",
"local",
"var",
"auth",
"names",
",",
"callback",
")",
";",
"}"
]
|
[
"this",
"method",
"is",
"deprecated",
"and",
"will",
"be",
"removed",
"in",
"the",
"future",
"releases",
"handle",
"async",
"db",
"operation",
"in",
"your",
"own",
"logic",
"instead"
]
| [
"public",
"<",
"t",
">",
"find",
"multi",
"executor",
"<",
"t",
">",
"find",
"async",
"(",
"final",
"class",
"<",
"t",
">",
"model",
"class",
")",
"{",
"return",
"find",
"async",
"(",
"model",
"class",
",",
"false",
")",
";",
"}"
]
|
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
]
| [
"private",
"string",
"to",
"indented",
"string",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
]
|
[
"returns",
"the",
"local",
"properties",
"which",
"are",
"present",
"after",
"the",
"operator",
"was",
"applied",
"on",
"the",
"provided",
"local",
"properties"
]
| [
"public",
"abstract",
"local",
"properties",
"compute",
"local",
"properties",
"(",
"local",
"properties",
"in",
")",
";"
]
|
[
"returns",
"true",
"if",
"the",
"method",
"is",
"abstract"
]
| [
"public",
"final",
"boolean",
"is",
"abstract",
"(",
")",
"{",
"return",
"modifier",
"is",
"abstract",
"(",
"get",
"modifiers",
"(",
")",
")",
";",
"}"
]
|
[
"returns",
"true",
"if",
"a",
"random",
"value",
"between",
"0",
"and",
"1",
"is",
"less",
"than",
"the",
"specified",
"value"
]
| [
"static",
"public",
"boolean",
"random",
"boolean",
"(",
"float",
"chance",
")",
"{",
"return",
"math",
"utils",
"random",
"(",
")",
"<",
"chance",
";",
"}"
]
|
[
"gets",
"the",
"application",
"'",
"s",
"version"
]
| [
"public",
"string",
"get",
"application",
"version",
"(",
")",
"{",
"string",
"app",
"version",
"=",
"get",
"property",
"(",
"application",
"properties",
"application",
"version",
"property",
")",
";",
"if",
"(",
"app",
"version",
"=",
"=",
"null",
"|",
"|",
"app",
"version",
"trim",
"(",
")",
"is",
"empty",
"(",
")",
")",
"{",
"return",
"\"",
"\"",
";",
"}",
"return",
"app",
"version",
";",
"}"
]
|
[
"returns",
"the",
"number",
"of",
"transferred",
"bytes"
]
| [
"public",
"long",
"transferred",
"bytes",
"(",
")",
"{",
"return",
"offset",
";",
"}"
]
|
[
"get",
"name",
"number"
]
| [
"public",
"big",
"decimal",
"get",
"name",
"number",
"(",
")",
"{",
"return",
"name",
"number",
";",
"}"
]
|
[
"the",
"following",
"tests",
"are",
"failing",
"on",
"azure",
"and",
"the",
"azure",
"file",
"system",
"code",
"needs",
"to",
"be",
"modified",
"to",
"make",
"them",
"pass",
"a",
"separate",
"work",
"item",
"has",
"been",
"opened",
"for",
"this"
]
| [
"public",
"void",
"test",
"move",
"file",
"under",
"parent",
"(",
")",
"throws",
"throwable",
"{",
"}"
]
|
[
"returns",
"a",
"formatted",
"string",
"representation",
"of",
"the",
"specified",
"code",
"unit",
"operand"
]
| [
"public",
"string",
"to",
"string",
"(",
")",
"{",
"string",
"buffer",
"str",
"buf",
"=",
"new",
"string",
"buffer",
"(",
")",
";",
"for",
"(",
"object",
"op",
"elem",
":",
"this",
")",
"{",
"str",
"buf",
"append",
"(",
"op",
"elem",
"to",
"string",
"(",
")",
")",
";",
"}",
"return",
"str",
"buf",
"to",
"string",
"(",
")",
";",
"}"
]
|
[
"abort",
"all",
"outstanding",
"m",
"p",
"us",
"older",
"than",
"a",
"given",
"age"
]
| [
"public",
"void",
"abort",
"outstanding",
"multipart",
"uploads",
"(",
"long",
"seconds",
")",
"throws",
"i",
"o",
"exception",
"{",
"preconditions",
"check",
"argument",
"(",
"seconds",
">",
"=",
"0",
")",
";",
"date",
"purge",
"before",
"=",
"new",
"date",
"(",
"new",
"date",
"(",
")",
"get",
"time",
"(",
")",
"-",
"seconds",
"*",
"1000",
")",
";",
"log",
"debug",
"(",
"\"",
"purging",
"outstanding",
"multipart",
"uploads",
"older",
"than",
"{",
"}",
"\"",
",",
"purge",
"before",
")",
";",
"invoker",
"retry",
"(",
"\"",
"purging",
"multipart",
"uploads",
"\"",
",",
"bucket",
",",
"true",
",",
"(",
")",
"-",
">",
"transfers",
"abort",
"multipart",
"uploads",
"(",
"bucket",
",",
"purge",
"before",
")",
")",
";",
"}"
]
|
[
"set",
"user",
"parameter"
]
| [
"void",
"set",
"parameter",
"(",
"string",
"name",
",",
"int",
"value",
")",
"{",
"set",
"modified",
"(",
")",
";",
"recovery",
"file",
"set",
"parameter",
"(",
"name",
",",
"value",
")",
";",
"}"
]
|
[
"defaults",
"to",
"type",
"\"",
"text",
"type",
"\""
]
| [
"public",
"final",
"alert",
"dialog",
"share",
"text",
"(",
"char",
"sequence",
"text",
")",
"{",
"return",
"share",
"text",
"(",
"text",
",",
"\"",
"text",
"type",
"\"",
")",
";",
"}"
]
|
[
"removing",
"fields",
"from",
"a",
"pojo",
"as",
"operator",
"state",
"should",
"succeed"
]
| [
"public",
"void",
"test",
"missing",
"field",
"with",
"operator",
"state",
"(",
")",
"throws",
"exception",
"{",
"test",
"pojo",
"serializer",
"upgrade",
"(",
"source",
"a",
",",
"source",
"e",
",",
"false",
",",
"false",
")",
";",
"}"
]
|
[
"test",
"the",
"property",
"'",
"array",
"array",
"of",
"integer",
"'"
]
| [
"public",
"void",
"array",
"array",
"of",
"integer",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"array",
"array",
"of",
"integer",
"}"
]
|
[
"sets",
"the",
"system",
"execution",
"time"
]
| [
"public",
"builder",
"set",
"system",
"execution",
"time",
"(",
"duration",
"system",
"execution",
"time",
")",
"{",
"this",
"system",
"execution",
"time",
"=",
"optional",
"of",
"(",
"system",
"execution",
"time",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"handles",
"an",
"exception",
"thrown",
"by",
"another",
"thread",
"(",
"e",
"g",
"a",
"trigger",
"task",
")",
",",
"other",
"than",
"the",
"one",
"executing",
"the",
"main",
"task",
"by",
"failing",
"the",
"task",
"entirely",
"in",
"more",
"detail",
",",
"it",
"marks",
"task",
"execution",
"failed",
"for",
"an",
"external",
"reason",
"(",
"a",
"reason",
"other",
"than",
"the",
"task",
"code",
"itself",
"throwing",
"an",
"exception",
")",
"if",
"the",
"task",
"is",
"already",
"in",
"a",
"terminal",
"state",
"(",
"such",
"as",
"finished",
",",
"canceled",
",",
"failed",
")",
",",
"or",
"if",
"the",
"task",
"is",
"already",
"canceling",
"this",
"does",
"nothing",
"otherwise",
"it",
"sets",
"the",
"state",
"to",
"failed",
",",
"and",
",",
"if",
"the",
"invokable",
"code",
"is",
"running",
",",
"starts",
"an",
"asynchronous",
"thread",
"that",
"aborts",
"that",
"code",
"this",
"method",
"never",
"blocks"
]
| [
"public",
"void",
"handle",
"async",
"exception",
"(",
"string",
"message",
",",
"throwable",
"exception",
")",
"{",
"if",
"(",
"is",
"running",
")",
"{",
"/",
"/",
"only",
"fail",
"if",
"the",
"task",
"is",
"still",
"running",
"async",
"exception",
"handler",
"handle",
"async",
"exception",
"(",
"message",
",",
"exception",
")",
";",
"}",
"}"
]
|
[
"reports",
"the",
"details",
"of",
"the",
"access",
"failure",
"this",
"method",
"is",
"similar",
"to",
"{",
"@",
"link",
"#",
"report",
"as",
"headers",
"(",
"http",
"servlet",
"response",
")",
"}",
"for",
"the",
"intention",
"but",
"instead",
"of",
"using",
"http",
"headers",
",",
"this",
"version",
"is",
"meant",
"to",
"go",
"inside",
"the",
"payload"
]
| [
"public",
"void",
"report",
"(",
"print",
"writer",
"w",
")",
"{",
"w",
"println",
"(",
"\"",
"you",
"are",
"authenticated",
"as",
":",
"\"",
"+",
"authentication",
"get",
"name",
"(",
")",
")",
";",
"w",
"println",
"(",
"\"",
"groups",
"that",
"you",
"are",
"in",
":",
"\"",
")",
";",
"for",
"(",
"granted",
"authority",
"auth",
":",
"authentication",
"get",
"authorities",
"(",
")",
")",
"{",
"w",
"println",
"(",
"\"",
"\"",
"+",
"auth",
"get",
"authority",
"(",
")",
")",
";",
"}",
"w",
"println",
"(",
"\"",
"permission",
"you",
"need",
"to",
"have",
"(",
"but",
"didn",
"'",
"t",
")",
":",
"\"",
"+",
"permission",
"get",
"id",
"(",
")",
")",
";",
"for",
"(",
"permission",
"p",
"=",
"permission",
"implied",
"by",
";",
"p",
"!",
"=",
"null",
";",
"p",
"=",
"p",
"implied",
"by",
")",
"{",
"w",
"println",
"(",
"\"",
"which",
"is",
"implied",
"by",
":",
"\"",
"+",
"p",
"get",
"id",
"(",
")",
")",
";",
"}",
"}"
]
|
[
"get",
"the",
"entity",
"id"
]
| [
"public",
"string",
"get",
"entity",
"id",
"(",
")",
"{",
"return",
"entity",
"id",
";",
"}"
]
|
[
"created",
"query",
"state",
"machines",
"must",
"be",
"transitioned",
"to",
"terminal",
"states",
"to",
"clean",
"up",
"resources"
]
| [
"public",
"static",
"query",
"state",
"machine",
"begin",
"(",
"string",
"query",
",",
"session",
"session",
",",
"uri",
"self",
",",
"resource",
"group",
"id",
"resource",
"group",
",",
"optional",
"<",
"query",
"type",
">",
"query",
"type",
",",
"boolean",
"transaction",
"control",
",",
"transaction",
"manager",
"transaction",
"manager",
",",
"access",
"control",
"access",
"control",
",",
"executor",
"executor",
",",
"metadata",
"metadata",
",",
"warning",
"collector",
"warning",
"collector",
")",
"{",
"return",
"begin",
"with",
"ticker",
"(",
"query",
",",
"session",
",",
"self",
",",
"resource",
"group",
",",
"query",
"type",
",",
"transaction",
"control",
",",
"transaction",
"manager",
",",
"access",
"control",
",",
"executor",
",",
"ticker",
"system",
"ticker",
"(",
")",
",",
"metadata",
",",
"warning",
"collector",
")",
";",
"}"
]
|
[
"ensures",
"that",
"the",
"given",
"variable",
"is",
"initialized",
"before",
"the",
"specified",
"consumer",
"of",
"that",
"variable",
",",
"in",
"the",
"jvm",
"'",
"s",
"view"
]
| [
"private",
"void",
"mark",
"variable",
"initializers",
"before",
"(",
"int",
"consumer",
"offset",
",",
"int",
"variable",
"index",
")",
"{",
"/",
"/",
"make",
"sure",
"the",
"variable",
"is",
"initialized",
"after",
"all",
"producers",
"/",
"/",
"use",
"the",
"simple",
"evaluator",
",",
"to",
"get",
"the",
"jvm",
"'",
"s",
"view",
"of",
"what",
"is",
"/",
"/",
"initialized",
"instruction",
"offset",
"value",
"producer",
"offsets",
"=",
"simple",
"partial",
"evaluator",
"get",
"variables",
"before",
"(",
"consumer",
"offset",
")",
"get",
"producer",
"value",
"(",
"variable",
"index",
")",
"instruction",
"offset",
"value",
"(",
")",
";",
"int",
"offset",
"count",
"=",
"producer",
"offsets",
"instruction",
"offset",
"count",
"(",
")",
";",
"for",
"(",
"int",
"offset",
"index",
"=",
"0",
";",
"offset",
"index",
"<",
"offset",
"count",
";",
"offset",
"index",
"+",
"+",
")",
"{",
"/",
"/",
"avoid",
"infinite",
"loops",
"by",
"only",
"looking",
"at",
"producers",
"before",
"/",
"/",
"the",
"consumer",
"only",
"consider",
"traced",
"producers",
"int",
"producer",
"offset",
"=",
"producer",
"offsets",
"instruction",
"offset",
"(",
"offset",
"index",
")",
";",
"if",
"(",
"producer",
"offset",
">",
"=",
"0",
"&",
"&",
"producer",
"offset",
"<",
"consumer",
"offset",
"&",
"&",
"partial",
"evaluator",
"is",
"traced",
"(",
"producer",
"offset",
")",
")",
"{",
"mark",
"variable",
"initializers",
"after",
"(",
"producer",
"offset",
",",
"variable",
"index",
")",
";",
"}",
"}",
"}"
]
|
[
"add",
"a",
"new",
"pet",
"to",
"the",
"store"
]
| [
"public",
"void",
"add",
"pet",
"test",
"(",
")",
"{",
"pet",
"pet",
"=",
"null",
";",
"api",
"add",
"pet",
"(",
"pet",
")",
"block",
"(",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
]
|
[
"persist",
"a",
"list",
"of",
"influencers",
"optionally",
"using",
"each",
"influencer",
"'",
"s",
"id",
"or",
"an",
"auto",
"generated",
"id"
]
| [
"public",
"builder",
"persist",
"influencers",
"(",
"list",
"<",
"influencer",
">",
"influencers",
")",
"{",
"for",
"(",
"influencer",
"influencer",
":",
"influencers",
")",
"{",
"logger",
"trace",
"(",
"\"",
"[",
"{",
"}",
"]",
"es",
"bulk",
"action",
":",
"index",
"influencer",
"to",
"index",
"[",
"{",
"}",
"]",
"with",
"id",
"[",
"{",
"}",
"]",
"\"",
",",
"job",
"id",
",",
"index",
"name",
",",
"influencer",
"get",
"id",
"(",
")",
")",
";",
"index",
"result",
"(",
"influencer",
"get",
"id",
"(",
")",
",",
"influencer",
",",
"\"",
"influencer",
"\"",
")",
";",
"}",
"return",
"this",
";",
"}"
]
|
[
"returns",
"an",
"unmodifiable",
"iterable",
"over",
"the",
"nodes",
"in",
"a",
"tree",
"structure",
",",
"using",
"breadth",
"-",
"first",
"traversal",
"that",
"is",
",",
"all",
"the",
"nodes",
"of",
"depth",
"0",
"are",
"returned",
",",
"then",
"depth",
"1",
",",
"then",
"2",
",",
"and",
"so",
"on",
"no",
"guarantees",
"are",
"made",
"about",
"the",
"behavior",
"of",
"the",
"traversal",
"when",
"nodes",
"change",
"while",
"iteration",
"is",
"in",
"progress",
"or",
"when",
"the",
"iterators",
"generated",
"by",
"{",
"@",
"link",
"#",
"children",
"}",
"are",
"advanced"
]
| [
"public",
"final",
"fluent",
"iterable",
"<",
"t",
">",
"breadth",
"first",
"traversal",
"(",
"final",
"t",
"root",
")",
"{",
"check",
"not",
"null",
"(",
"root",
")",
";",
"return",
"new",
"fluent",
"iterable",
"<",
"t",
">",
"(",
")",
"{",
"@",
"override",
"public",
"unmodifiable",
"iterator",
"<",
"t",
">",
"iterator",
"(",
")",
"{",
"return",
"new",
"breadth",
"first",
"iterator",
"(",
"root",
")",
";",
"}",
"}",
";",
"}"
]
|
[
"get",
"name",
"integer"
]
| [
"public",
"integer",
"get",
"name",
"integer",
"(",
")",
"{",
"return",
"name",
"integer",
";",
"}"
]
|
[
"applies",
"an",
"aggregation",
"that",
"gives",
"the",
"minimum",
"element",
"of",
"every",
"window",
"of",
"the",
"data",
"stream",
"by",
"the",
"given",
"position",
"if",
"more",
"elements",
"have",
"the",
"same",
"minimum",
"value",
"the",
"operator",
"returns",
"the",
"first",
"element",
"by",
"default"
]
| [
"public",
"single",
"output",
"stream",
"operator",
"<",
"t",
">",
"min",
"by",
"(",
"int",
"position",
"to",
"min",
"by",
")",
"{",
"return",
"this",
"min",
"by",
"(",
"position",
"to",
"min",
"by",
",",
"true",
")",
";",
"}"
]
|
[
"applies",
"the",
"given",
"{",
"@",
"code",
"aggregate",
"function",
"}",
"to",
"each",
"window",
"the",
"aggregate",
"function",
"aggregates",
"all",
"elements",
"of",
"a",
"window",
"into",
"a",
"single",
"result",
"element",
"the",
"stream",
"of",
"these",
"result",
"elements",
"(",
"one",
"per",
"window",
")",
"is",
"interpreted",
"as",
"a",
"regular",
"non",
"-",
"windowed",
"stream"
]
| [
"public",
"<",
"acc",
",",
"r",
">",
"single",
"output",
"stream",
"operator",
"<",
"r",
">",
"aggregate",
"(",
"aggregate",
"function",
"<",
"t",
",",
"acc",
",",
"r",
">",
"function",
",",
"type",
"information",
"<",
"acc",
">",
"accumulator",
"type",
",",
"type",
"information",
"<",
"r",
">",
"result",
"type",
")",
"{",
"check",
"not",
"null",
"(",
"function",
",",
"\"",
"function",
"\"",
")",
";",
"check",
"not",
"null",
"(",
"accumulator",
"type",
",",
"\"",
"accumulator",
"type",
"\"",
")",
";",
"check",
"not",
"null",
"(",
"result",
"type",
",",
"\"",
"result",
"type",
"\"",
")",
";",
"if",
"(",
"function",
"instanceof",
"rich",
"function",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
"\"",
"this",
"aggregation",
"function",
"cannot",
"be",
"a",
"rich",
"function",
"\"",
")",
";",
"}",
"return",
"aggregate",
"(",
"function",
",",
"new",
"pass",
"through",
"all",
"window",
"function",
"<",
"w",
",",
"r",
">",
"(",
")",
",",
"accumulator",
"type",
",",
"result",
"type",
")",
";",
"}"
]
|
[
"deletes",
"a",
"pet"
]
| [
"public",
"single",
"<",
"void",
">",
"rx",
"delete",
"pet",
"(",
"long",
"pet",
"id",
",",
"string",
"api",
"key",
")",
"{",
"return",
"single",
"create",
"(",
"new",
"io",
"vertx",
"rx",
"java",
"single",
"on",
"subscribe",
"adapter",
"<",
">",
"(",
"fut",
"-",
">",
"delegate",
"delete",
"pet",
"(",
"pet",
"id",
",",
"api",
"key",
",",
"fut",
")",
")",
")",
";",
"}"
]
|
[
"invoked",
"at",
"start",
"of",
"thread",
"execution",
"when",
"{",
"@",
"link",
"hystrix",
"command",
"}",
"is",
"executed",
"using",
"{",
"@",
"link",
"execution",
"isolation",
"strategy",
"#",
"thread",
"}"
]
| [
"public",
"<",
"t",
">",
"void",
"on",
"thread",
"start",
"(",
"hystrix",
"invokable",
"<",
"t",
">",
"command",
"instance",
")",
"{",
"/",
"/",
"do",
"nothing",
"by",
"default",
"}"
]
|
[
"exit",
"a",
"parse",
"tree",
"produced",
"by",
"the",
"{",
"@",
"code",
"function",
"}",
"labeled",
"alternative",
"in",
"{",
"@",
"link",
"eql",
"base",
"parser",
"#",
"primary",
"expression",
"}"
]
| [
"void",
"exit",
"function",
"(",
"eql",
"base",
"parser",
"function",
"context",
"ctx",
")",
";"
]
|
[
"if",
"it",
"'",
"s",
"not",
"changing",
"configuration",
"(",
"i",
"e",
"rotating",
"screen",
")",
",",
"try",
"to",
"write",
"the",
"state",
"from",
"{",
"@",
"link",
"state",
"saver",
"write",
"read",
"#",
"write",
"to",
"(",
"queue",
")",
"}",
"to",
"the",
"file",
"with",
"the",
"name",
"of",
"prefix",
"file",
"name",
"+",
"suffix",
"file",
"name",
",",
"in",
"a",
"cache",
"folder",
"got",
"from",
"the",
"{",
"@",
"link",
"#",
"init",
"(",
"context",
")",
"}",
"it",
"checks",
"if",
"the",
"file",
"already",
"exists",
"and",
"if",
"it",
"does",
",",
"just",
"return",
"the",
"path",
",",
"so",
"a",
"good",
"way",
"to",
"save",
"is",
":",
"a",
"fixed",
"prefix",
"for",
"the",
"file",
"a",
"changing",
"suffix"
]
| [
"private",
"static",
"saved",
"state",
"try",
"to",
"save",
"(",
"final",
"boolean",
"is",
"changing",
"config",
",",
"final",
"string",
"prefix",
"file",
"name",
",",
"final",
"string",
"suffix",
"file",
"name",
",",
"final",
"write",
"read",
"write",
"read",
")",
"{",
"if",
"(",
"main",
"activity",
"debug",
")",
"{",
"log",
"d",
"(",
"tag",
",",
"\"",
"try",
"to",
"save",
"(",
")",
"called",
"with",
":",
"\"",
"+",
"\"",
"is",
"changing",
"config",
"=",
"[",
"\"",
"+",
"is",
"changing",
"config",
"+",
"\"",
"]",
",",
"\"",
"+",
"\"",
"prefix",
"file",
"name",
"=",
"[",
"\"",
"+",
"prefix",
"file",
"name",
"+",
"\"",
"]",
",",
"\"",
"+",
"\"",
"suffix",
"file",
"name",
"=",
"[",
"\"",
"+",
"suffix",
"file",
"name",
"+",
"\"",
"]",
",",
"\"",
"+",
"\"",
"write",
"read",
"=",
"[",
"\"",
"+",
"write",
"read",
"+",
"\"",
"]",
"\"",
")",
";",
"}",
"final",
"linked",
"list",
"<",
"object",
">",
"saved",
"objects",
"=",
"new",
"linked",
"list",
"<",
">",
"(",
")",
";",
"write",
"read",
"write",
"to",
"(",
"saved",
"objects",
")",
";",
"if",
"(",
"is",
"changing",
"config",
")",
"{",
"if",
"(",
"saved",
"objects",
"size",
"(",
")",
">",
"0",
")",
"{",
"state",
"objects",
"holder",
"put",
"(",
"prefix",
"file",
"name",
",",
"saved",
"objects",
")",
";",
"return",
"new",
"saved",
"state",
"(",
"prefix",
"file",
"name",
",",
"\"",
"\"",
")",
";",
"}",
"else",
"{",
"if",
"(",
"main",
"activity",
"debug",
")",
"{",
"log",
"d",
"(",
"tag",
",",
"\"",
"nothing",
"to",
"save",
"\"",
")",
";",
"}",
"return",
"null",
";",
"}",
"}",
"try",
"{",
"file",
"cache",
"dir",
"=",
"new",
"file",
"(",
"cache",
"dir",
"path",
")",
";",
"if",
"(",
"!",
"cache",
"dir",
"exists",
"(",
")",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"\"",
"cache",
"dir",
"does",
"not",
"exist",
">",
"\"",
"+",
"cache",
"dir",
"path",
")",
";",
"}",
"cache",
"dir",
"=",
"new",
"file",
"(",
"cache",
"dir",
",",
"cache",
"dir",
"name",
")",
";",
"if",
"(",
"!",
"cache",
"dir",
"exists",
"(",
")",
")",
"{",
"if",
"(",
"!",
"cache",
"dir",
"mkdir",
"(",
")",
")",
"{",
"if",
"(",
"build",
"config",
"debug",
")",
"{",
"log",
"e",
"(",
"tag",
",",
"\"",
"failed",
"to",
"create",
"cache",
"directory",
"\"",
"+",
"cache",
"dir",
"get",
"absolute",
"path",
"(",
")",
")",
";",
"}",
"return",
"null",
";",
"}",
"}",
"final",
"file",
"file",
"=",
"new",
"file",
"(",
"cache",
"dir",
",",
"prefix",
"file",
"name",
"+",
"(",
"text",
"utils",
"is",
"empty",
"(",
"suffix",
"file",
"name",
")",
"?",
"\"",
"cache",
"\"",
":",
"suffix",
"file",
"name",
")",
")",
";",
"if",
"(",
"file",
"exists",
"(",
")",
"&",
"&",
"file",
"length",
"(",
")",
">",
"0",
")",
"{",
"/",
"/",
"if",
"the",
"file",
"already",
"exists",
",",
"just",
"return",
"it",
"return",
"new",
"saved",
"state",
"(",
"prefix",
"file",
"name",
",",
"file",
"get",
"absolute",
"path",
"(",
")",
")",
";",
"}",
"else",
"{",
"/",
"/",
"delete",
"any",
"file",
"that",
"contains",
"the",
"prefix",
"final",
"file",
"[",
"]",
"files",
"=",
"cache",
"dir",
"list",
"files",
"(",
"(",
"dir",
",",
"name",
")",
"-",
">",
"name",
"contains",
"(",
"prefix",
"file",
"name",
")",
")",
";",
"for",
"(",
"final",
"file",
"file",
"to",
"delete",
":",
"files",
")",
"{",
"file",
"to",
"delete",
"delete",
"(",
")",
";",
"}",
"}",
"try",
"(",
"file",
"output",
"stream",
"file",
"output",
"stream",
"=",
"new",
"file",
"output",
"stream",
"(",
"file",
")",
";",
"object",
"output",
"stream",
"output",
"stream",
"=",
"new",
"object",
"output",
"stream",
"(",
"file",
"output",
"stream",
")",
")",
"{",
"output",
"stream",
"write",
"object",
"(",
"saved",
"objects",
")",
";",
"}",
"return",
"new",
"saved",
"state",
"(",
"prefix",
"file",
"name",
",",
"file",
"get",
"absolute",
"path",
"(",
")",
")",
";",
"}",
"catch",
"(",
"final",
"exception",
"e",
")",
"{",
"log",
"e",
"(",
"tag",
",",
"\"",
"failed",
"to",
"save",
"state",
"\"",
",",
"e",
")",
";",
"}",
"return",
"null",
";",
"}"
]
|
[
"convert",
"milliseconds",
"to",
"human",
"time",
"-",
"the",
"exact",
"format",
"is",
"unspecified"
]
| [
"public",
"static",
"string",
"millis",
"to",
"human",
"time",
"(",
"long",
"milliseconds",
")",
"{",
"string",
"builder",
"sb",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"/",
"/",
"send",
"all",
"output",
"to",
"the",
"appendable",
"object",
"sb",
"formatter",
"formatter",
"=",
"new",
"formatter",
"(",
"sb",
",",
"locale",
"us",
")",
";",
"long",
"s",
"=",
"math",
"abs",
"(",
"milliseconds",
"/",
"1000",
")",
";",
"long",
"m",
"=",
"math",
"abs",
"(",
"milliseconds",
"%",
"1000",
")",
";",
"if",
"(",
"milliseconds",
">",
"0",
")",
"{",
"formatter",
"format",
"(",
"\"",
"%",
"d",
"%",
"0",
"3ds",
"\"",
",",
"s",
",",
"m",
")",
";",
"}",
"else",
"if",
"(",
"milliseconds",
"=",
"=",
"0",
")",
"{",
"formatter",
"format",
"(",
"\"",
"0",
"\"",
")",
";",
"}",
"else",
"{",
"formatter",
"format",
"(",
"\"",
"-",
"%",
"d",
"%",
"0",
"3ds",
"\"",
",",
"s",
",",
"m",
")",
";",
"}",
"return",
"sb",
"to",
"string",
"(",
")",
";",
"}"
]
|
[
"used",
"to",
"get",
"properties",
"from",
"the",
"os",
"environment"
]
| [
"public",
"static",
"configuration",
"get",
"env",
"configuration",
"(",
")",
"{",
"return",
"application",
"model",
"get",
"environment",
"(",
")",
"get",
"environment",
"configuration",
"(",
")",
";",
"}"
]
|
[
"used",
"to",
"load",
"a",
"string",
"via",
"line",
"number",
"line",
"number",
"=",
"-",
"1",
"means",
"random"
]
| [
"public",
"static",
"string",
"load",
"string",
"(",
"string",
"file",
"name",
",",
"int",
"line",
"number",
",",
"boolean",
"cache",
")",
"throws",
"exception",
"{",
"array",
"list",
"<",
"string",
">",
"array",
";",
"if",
"(",
"!",
"map",
"contains",
"key",
"(",
"file",
"name",
")",
")",
"{",
"array",
"=",
"new",
"array",
"list",
"<",
"string",
">",
"(",
")",
";",
"file",
"file",
"=",
"new",
"file",
"(",
"file",
"name",
")",
";",
"buffered",
"reader",
"reader",
"=",
"new",
"buffered",
"reader",
"(",
"new",
"file",
"reader",
"(",
"file",
")",
")",
";",
"string",
"add",
";",
"while",
"(",
"(",
"add",
"=",
"reader",
"read",
"line",
"(",
")",
")",
"!",
"=",
"null",
")",
"array",
"add",
"(",
"add",
")",
";",
"reader",
"close",
"(",
")",
";",
"if",
"(",
"cache",
")",
"map",
"put",
"(",
"file",
"name",
",",
"array",
")",
";",
"}",
"else",
"{",
"array",
"=",
"map",
"get",
"(",
"file",
"name",
")",
";",
"}",
"if",
"(",
"line",
"number",
"=",
"=",
"-",
"1",
")",
"{",
"int",
"size",
"=",
"array",
"size",
"(",
")",
";",
"return",
"array",
"get",
"(",
"random",
"next",
"int",
"(",
"size",
")",
")",
";",
"}",
"else",
"return",
"array",
"get",
"(",
"line",
"number",
")",
";",
"}"
]
|
[
"adds",
"a",
"node",
"connected",
"behavior",
"that",
"is",
"the",
"default",
"node",
"connected",
"behavior"
]
| [
"public",
"boolean",
"add",
"node",
"connected",
"behavior",
"(",
"stubbable",
"connection",
"manager",
"node",
"connected",
"behavior",
"behavior",
")",
"{",
"return",
"connection",
"manager",
"(",
")",
"set",
"default",
"node",
"connected",
"behavior",
"(",
"behavior",
")",
";",
"}"
]
|
[
"expect",
"that",
"the",
"header",
"with",
"the",
"given",
"name",
"is",
"present"
]
| [
"public",
"web",
"test",
"client",
"response",
"spec",
"exists",
"(",
"string",
"name",
")",
"{",
"if",
"(",
"!",
"get",
"headers",
"(",
")",
"contains",
"key",
"(",
"name",
")",
")",
"{",
"string",
"message",
"=",
"get",
"message",
"(",
"name",
")",
"+",
"\"",
"does",
"not",
"exist",
"\"",
";",
"this",
"exchange",
"result",
"assert",
"with",
"diagnostics",
"(",
"(",
")",
"-",
">",
"assertion",
"errors",
"fail",
"(",
"message",
")",
")",
";",
"}",
"return",
"this",
"response",
"spec",
";",
"}"
]
|
[
"implementation",
"of",
"the",
"starlark",
"{",
"@",
"code",
"select",
"}",
"function",
"exposed",
"to",
"build",
"and",
"bzl",
"files"
]
| [
"public",
"static",
"object",
"select",
"(",
"dict",
"<",
"?",
",",
"?",
">",
"dict",
",",
"string",
"no",
"match",
"error",
")",
"throws",
"eval",
"exception",
"{",
"if",
"(",
"dict",
"is",
"empty",
"(",
")",
")",
"{",
"throw",
"starlark",
"errorf",
"(",
"\"",
"select",
"(",
"{",
"}",
")",
"with",
"an",
"empty",
"dictionary",
"can",
"never",
"resolve",
"because",
"it",
"includes",
"no",
"conditions",
"\"",
"+",
"\"",
"to",
"match",
"\"",
")",
";",
"}",
"for",
"(",
"object",
"key",
":",
"dict",
"key",
"set",
"(",
")",
")",
"{",
"if",
"(",
"!",
"(",
"key",
"instanceof",
"string",
")",
")",
"{",
"throw",
"starlark",
"errorf",
"(",
"\"",
"select",
":",
"got",
"%",
"s",
"for",
"dict",
"key",
",",
"want",
"a",
"label",
"string",
"\"",
",",
"starlark",
"type",
"(",
"key",
")",
")",
";",
"}",
"}",
"return",
"selector",
"list",
"of",
"(",
"new",
"selector",
"value",
"(",
"dict",
",",
"no",
"match",
"error",
")",
")",
";",
"}"
]
|
[
"set",
"the",
"script",
"source",
"directories",
"to",
"be",
"searched",
"for",
"secondary",
"scripts",
"the",
"default",
"set",
"of",
"enabled",
"script",
"directories",
"within",
"the",
"ghidra",
"installation",
"will",
"be",
"appended",
"to",
"the",
"specified",
"list",
"of",
"new",
"paths",
"individual",
"paths",
"may",
"be",
"constructed",
"relative",
"to",
"ghidra",
"installation",
"directory",
",",
"user",
"home",
"directory",
",",
"or",
"absolute",
"system",
"paths",
"examples",
":",
"path",
"ghidra",
"home",
"+",
"\"",
"ghidra",
"features",
"baseghidra",
"scripts",
"\"",
"path",
"user",
"home",
"+",
"\"",
"ghidra",
"features",
"baseghidra",
"scripts",
"\"",
"\"",
"sharedghidra",
"scripts",
"\""
]
| [
"public",
"void",
"set",
"script",
"directories",
"(",
"list",
"<",
"string",
">",
"new",
"paths",
")",
"{",
"script",
"paths",
"=",
"new",
"paths",
";",
"}"
]
|
[
"indicates",
"whether",
"the",
"given",
"type",
"can",
"be",
"read",
"by",
"this",
"converter",
"this",
"method",
"should",
"perform",
"the",
"same",
"checks",
"than",
"{",
"@",
"link",
"http",
"message",
"converter",
"#",
"can",
"read",
"(",
"class",
",",
"media",
"type",
")",
"}",
"with",
"additional",
"ones",
"related",
"to",
"the",
"generic",
"type"
]
| [
"boolean",
"can",
"read",
"(",
"type",
"type",
",",
"@",
"nullable",
"class",
"<",
"?",
">",
"context",
"class",
",",
"@",
"nullable",
"media",
"type",
"media",
"type",
")",
";"
]
|
[
"applies",
"an",
"aggregation",
"that",
"gives",
"the",
"current",
"element",
"with",
"the",
"maximum",
"value",
"at",
"the",
"given",
"position",
"by",
"the",
"given",
"key",
"an",
"independent",
"aggregate",
"is",
"kept",
"per",
"key",
"if",
"more",
"elements",
"have",
"the",
"maximum",
"value",
"at",
"the",
"given",
"position",
",",
"the",
"operator",
"returns",
"either",
"the",
"first",
"or",
"last",
"one",
",",
"depending",
"on",
"the",
"parameter",
"set"
]
| [
"public",
"single",
"output",
"stream",
"operator",
"<",
"t",
">",
"max",
"by",
"(",
"int",
"position",
"to",
"max",
"by",
",",
"boolean",
"first",
")",
"{",
"return",
"aggregate",
"(",
"new",
"comparable",
"aggregator",
"<",
">",
"(",
"position",
"to",
"max",
"by",
",",
"get",
"type",
"(",
")",
",",
"aggregation",
"function",
"aggregation",
"type",
"maxby",
",",
"first",
",",
"get",
"execution",
"config",
"(",
")",
")",
")",
";",
"}"
]
|
[
"return",
"the",
"error",
"instance",
"associated",
"with",
"this",
"exception",
"or",
"any",
"of",
"its",
"superclasses",
"(",
"or",
"unknown",
"if",
"there",
"is",
"none",
")",
"if",
"there",
"are",
"multiple",
"matches",
"in",
"the",
"class",
"hierarchy",
",",
"the",
"first",
"match",
"starting",
"from",
"the",
"bottom",
"is",
"used"
]
| [
"public",
"static",
"errors",
"for",
"exception",
"(",
"throwable",
"t",
")",
"{",
"class",
"<",
"?",
">",
"clazz",
"=",
"t",
"get",
"class",
"(",
")",
";",
"while",
"(",
"clazz",
"!",
"=",
"null",
")",
"{",
"errors",
"error",
"=",
"class",
"to",
"error",
"get",
"(",
"clazz",
")",
";",
"if",
"(",
"error",
"!",
"=",
"null",
")",
"return",
"error",
";",
"clazz",
"=",
"clazz",
"get",
"superclass",
"(",
")",
";",
"}",
"return",
"unknown",
"server",
"error",
";",
"}"
]
|
[
"throws",
"{",
"@",
"code",
"unsupported",
"operation",
"exception",
"}",
"setting",
"seeds",
"in",
"this",
"generator",
"is",
"not",
"supported"
]
| [
"public",
"void",
"set",
"seed",
"(",
"long",
"seed",
")",
"{",
"if",
"(",
"initialized",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
")",
";",
"}",
"rnd",
"=",
"(",
"seed",
"^",
"multiplier",
")",
"&",
"mask",
";",
"}"
]
|
[
"reads",
"all",
"bytes",
"from",
"an",
"input",
"stream",
"into",
"a",
"byte",
"array",
"does",
"not",
"close",
"the",
"stream"
]
| [
"public",
"static",
"byte",
"[",
"]",
"to",
"byte",
"array",
"(",
"input",
"stream",
"in",
")",
"throws",
"i",
"o",
"exception",
"{",
"check",
"not",
"null",
"(",
"in",
")",
";",
"return",
"to",
"byte",
"array",
"internal",
"(",
"in",
",",
"new",
"array",
"deque",
"<",
"byte",
"[",
"]",
">",
"(",
"to",
"byte",
"array",
"deque",
"size",
")",
",",
"0",
")",
";",
"}"
]
|
[
"checks",
"that",
"s",
"s",
"l",
"factory",
"initialization",
"is",
"successful",
"with",
"the",
"given",
"arguments",
"this",
"is",
"a",
"helper",
"method",
"for",
"writing",
"test",
"cases",
"that",
"cover",
"different",
"combinations",
"of",
"settings",
"for",
"the",
"store",
"password",
"and",
"key",
"password",
"it",
"takes",
"care",
"of",
"bootstrapping",
"a",
"keystore",
",",
"a",
"truststore",
",",
"and",
"ssl",
"client",
"or",
"server",
"configuration",
"then",
",",
"it",
"initializes",
"an",
"s",
"s",
"l",
"factory",
"if",
"no",
"exception",
"is",
"thrown",
",",
"then",
"initialization",
"was",
"successful"
]
| [
"private",
"void",
"check",
"s",
"s",
"l",
"factory",
"init",
"with",
"passwords",
"(",
"s",
"s",
"l",
"factory",
"mode",
"mode",
",",
"string",
"password",
",",
"string",
"key",
"password",
",",
"string",
"conf",
"password",
",",
"string",
"conf",
"key",
"password",
")",
"throws",
"exception",
"{",
"check",
"s",
"s",
"l",
"factory",
"init",
"with",
"passwords",
"(",
"mode",
",",
"password",
",",
"key",
"password",
",",
"conf",
"password",
",",
"conf",
"key",
"password",
",",
"false",
")",
";",
"}"
]
|
[
"sets",
"the",
"number",
"of",
"shard",
"results",
"that",
"should",
"be",
"reduced",
"at",
"once",
"on",
"the",
"coordinating",
"node",
"this",
"value",
"should",
"be",
"used",
"as",
"a",
"protection",
"mechanism",
"to",
"reduce",
"the",
"memory",
"overhead",
"per",
"search",
"request",
"if",
"the",
"potential",
"number",
"of",
"shards",
"in",
"the",
"request",
"can",
"be",
"large"
]
| [
"public",
"search",
"request",
"builder",
"set",
"batched",
"reduce",
"size",
"(",
"int",
"batched",
"reduce",
"size",
")",
"{",
"this",
"request",
"set",
"batched",
"reduce",
"size",
"(",
"batched",
"reduce",
"size",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"returns",
"a",
"{",
"@",
"link",
"cache",
"directive",
"info",
"}",
"based",
"on",
"this",
"cache",
"directive",
"this",
"always",
"sets",
"an",
"absolute",
"expiry",
"time",
",",
"never",
"a",
"relative",
"ttl"
]
| [
"public",
"cache",
"directive",
"info",
"to",
"info",
"(",
")",
"{",
"return",
"new",
"cache",
"directive",
"info",
"builder",
"(",
")",
"set",
"id",
"(",
"id",
")",
"set",
"path",
"(",
"new",
"path",
"(",
"path",
")",
")",
"set",
"replication",
"(",
"replication",
")",
"set",
"pool",
"(",
"pool",
"get",
"pool",
"name",
"(",
")",
")",
"set",
"expiration",
"(",
"cache",
"directive",
"info",
"expiration",
"new",
"absolute",
"(",
"expiry",
"time",
")",
")",
"build",
"(",
")",
";",
"}"
]
|
[
"configure",
"the",
"pipeline",
"for",
"a",
"cleartext",
"upgrade",
"from",
"http",
"to",
"http2",
"0"
]
| [
"private",
"void",
"configure",
"clear",
"text",
"(",
"socket",
"channel",
"ch",
")",
"{",
"final",
"channel",
"pipeline",
"p",
"=",
"ch",
"pipeline",
"(",
")",
";",
"final",
"http",
"server",
"codec",
"source",
"codec",
"=",
"new",
"http",
"server",
"codec",
"(",
")",
";",
"final",
"http",
"server",
"upgrade",
"handler",
"upgrade",
"handler",
"=",
"new",
"http",
"server",
"upgrade",
"handler",
"(",
"source",
"codec",
",",
"upgrade",
"codec",
"factory",
")",
";",
"final",
"cleartext",
"http",
"2",
"server",
"upgrade",
"handler",
"cleartext",
"http",
"2",
"server",
"upgrade",
"handler",
"=",
"new",
"cleartext",
"http",
"2",
"server",
"upgrade",
"handler",
"(",
"source",
"codec",
",",
"upgrade",
"handler",
",",
"new",
"hello",
"world",
"http",
"2",
"handler",
"builder",
"(",
")",
"build",
"(",
")",
")",
";",
"p",
"add",
"last",
"(",
"cleartext",
"http",
"2",
"server",
"upgrade",
"handler",
")",
";",
"p",
"add",
"last",
"(",
"new",
"simple",
"channel",
"inbound",
"handler",
"<",
"http",
"message",
">",
"(",
")",
"{",
"@",
"override",
"protected",
"void",
"channel",
"read",
"0",
"(",
"channel",
"handler",
"context",
"ctx",
",",
"http",
"message",
"msg",
")",
"throws",
"exception",
"{",
"/",
"/",
"if",
"this",
"handler",
"is",
"hit",
"then",
"no",
"upgrade",
"has",
"been",
"attempted",
"and",
"the",
"client",
"is",
"just",
"talking",
"http",
"system",
"err",
"println",
"(",
"\"",
"directly",
"talking",
":",
"\"",
"+",
"msg",
"protocol",
"version",
"(",
")",
"+",
"\"",
"(",
"no",
"upgrade",
"was",
"attempted",
")",
"\"",
")",
";",
"channel",
"pipeline",
"pipeline",
"=",
"ctx",
"pipeline",
"(",
")",
";",
"channel",
"handler",
"context",
"this",
"ctx",
"=",
"pipeline",
"context",
"(",
"this",
")",
";",
"pipeline",
"add",
"after",
"(",
"this",
"ctx",
"name",
"(",
")",
",",
"null",
",",
"new",
"hello",
"world",
"http",
"1",
"handler",
"(",
"\"",
"direct",
"no",
"upgrade",
"attempted",
"\"",
")",
")",
";",
"pipeline",
"replace",
"(",
"this",
",",
"null",
",",
"new",
"http",
"object",
"aggregator",
"(",
"max",
"http",
"content",
"length",
")",
")",
";",
"ctx",
"fire",
"channel",
"read",
"(",
"reference",
"count",
"util",
"retain",
"(",
"msg",
")",
")",
";",
"}",
"}",
")",
";",
"p",
"add",
"last",
"(",
"new",
"user",
"event",
"logger",
"(",
")",
")",
";",
"}"
]
|
[
"aggregate",
"the",
"sampling",
"ip",
"and",
"monitoring",
"configuration",
"information",
"in",
"the",
"sampling",
"results",
"there",
"is",
"no",
"problem",
"for",
"the",
"merging",
"strategy",
"to",
"cover",
"the",
"previous",
"one",
"with",
"the",
"latter"
]
| [
"public",
"sample",
"result",
"merge",
"sample",
"result",
"(",
"list",
"<",
"sample",
"result",
">",
"sample",
"results",
")",
"{",
"sample",
"result",
"merge",
"result",
"=",
"new",
"sample",
"result",
"(",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"lisenters",
"groupkey",
"status",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"string",
">",
"(",
"50",
")",
";",
"for",
"(",
"sample",
"result",
"sample",
"result",
":",
"sample",
"results",
")",
"{",
"map",
"<",
"string",
",",
"string",
">",
"lisenters",
"groupkey",
"status",
"tmp",
"=",
"sample",
"result",
"get",
"lisenters",
"groupkey",
"status",
"(",
")",
";",
"for",
"(",
"map",
"entry",
"<",
"string",
",",
"string",
">",
"entry",
":",
"lisenters",
"groupkey",
"status",
"tmp",
"entry",
"set",
"(",
")",
")",
"{",
"lisenters",
"groupkey",
"status",
"put",
"(",
"entry",
"get",
"key",
"(",
")",
",",
"entry",
"get",
"value",
"(",
")",
")",
";",
"}",
"}",
"merge",
"result",
"set",
"lisenters",
"groupkey",
"status",
"(",
"lisenters",
"groupkey",
"status",
")",
";",
"return",
"merge",
"result",
";",
"}"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.