docstring_tokens
list | code_tokens
list |
|---|---|
[
"returns",
"all",
"partitions",
"for",
"which",
"no",
"offests",
"are",
"defined"
] |
[
"public",
"set",
"<",
"topic",
"partition",
">",
"partitions",
"(",
")",
"{",
"return",
"partitions",
";",
"}"
] |
[
"use",
"secure",
"mode",
",",
"which",
"will",
"automatically",
"switch",
"to",
"sas",
","
] |
[
"public",
"void",
"test",
"connect",
"using",
"secure",
"s",
"a",
"s",
"(",
")",
"throws",
"exception",
"{",
"/",
"/",
"create",
"the",
"test",
"account",
"with",
"sas",
"credentials",
"configuration",
"conf",
"=",
"new",
"configuration",
"(",
")",
";",
"conf",
"set",
"boolean",
"(",
"azure",
"native",
"file",
"system",
"store",
"key",
"use",
"secure",
"mode",
",",
"true",
")",
";",
"test",
"account",
"=",
"azure",
"blob",
"storage",
"test",
"account",
"create",
"(",
"\"",
"\"",
",",
"enum",
"set",
"of",
"(",
"create",
"options",
"use",
"sas",
")",
",",
"conf",
")",
";",
"assume",
"not",
"null",
"(",
"test",
"account",
")",
";",
"native",
"azure",
"file",
"system",
"fs",
"=",
"test",
"account",
"get",
"file",
"system",
"(",
")",
";",
"azure",
"exception",
"ex",
"=",
"intercept",
"(",
"azure",
"exception",
"class",
",",
"sr",
"enumeration",
"error",
",",
"(",
")",
"-",
">",
"contract",
"test",
"utils",
"write",
"text",
"file",
"(",
"fs",
",",
"new",
"path",
"(",
"\"",
"/",
"test",
"connect",
"using",
"secure",
"s",
"a",
"s",
"\"",
")",
",",
"\"",
"test",
"connect",
"using",
"secure",
"s",
"a",
"s",
"\"",
",",
"true",
")",
")",
";",
"storage",
"exception",
"cause",
"=",
"get",
"cause",
"(",
"storage",
"exception",
"class",
",",
"get",
"cause",
"(",
"no",
"such",
"element",
"exception",
"class",
",",
"ex",
")",
")",
";",
"generic",
"test",
"utils",
"assert",
"exception",
"contains",
"(",
"\"",
"the",
"specified",
"container",
"does",
"not",
"exist",
"\"",
",",
"cause",
")",
";",
"}"
] |
[
"increases",
"the",
"size",
"of",
"the",
"backing",
"array",
"to",
"accommodate",
"the",
"specified",
"number",
"of",
"additional",
"items",
"load",
"factor",
"useful",
"before",
"adding",
"many",
"items",
"to",
"avoid",
"multiple",
"backing",
"array",
"resizes"
] |
[
"public",
"void",
"ensure",
"capacity",
"(",
"int",
"additional",
"capacity",
")",
"{",
"int",
"table",
"size",
"=",
"table",
"size",
"(",
"size",
"+",
"additional",
"capacity",
",",
"load",
"factor",
")",
";",
"if",
"(",
"key",
"table",
"length",
"<",
"table",
"size",
")",
"resize",
"(",
"table",
"size",
")",
";",
"}"
] |
[
"finalize",
"previously",
"upgraded",
"files",
"system",
"state"
] |
[
"public",
"void",
"finalize",
"upgrade",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"dfs",
"finalize",
"upgrade",
"(",
")",
";",
"}"
] |
[
"register",
"the",
"dubbo",
"shutdown",
"hook"
] |
[
"private",
"static",
"void",
"register",
"dubbo",
"shutdown",
"hook",
"(",
")",
"{",
"shutdown",
"hook",
"callbacks",
"instance",
"add",
"callback",
"(",
"(",
")",
"-",
">",
"{",
"watch",
"service",
"if",
"present",
"(",
"w",
"-",
">",
"{",
"try",
"{",
"w",
"close",
"(",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"e",
")",
";",
"}",
"}",
")",
";",
"get",
"watch",
"events",
"loop",
"thread",
"pool",
"(",
")",
"shutdown",
"(",
")",
";",
"}",
")",
";",
"}"
] |
[
"to",
"-",
"many",
"relationship",
",",
"resolved",
"on",
"first",
"access",
"(",
"and",
"after",
"reset",
")",
"changes",
"to",
"to",
"-",
"many",
"relations",
"are",
"not",
"persisted",
",",
"make",
"changes",
"to",
"the",
"target",
"entity"
] |
[
"public",
"list",
"<",
"tree",
"entity",
">",
"get",
"children",
"(",
")",
"{",
"if",
"(",
"children",
"=",
"=",
"null",
")",
"{",
"throw",
"if",
"detached",
"(",
")",
";",
"tree",
"entity",
"dao",
"target",
"dao",
"=",
"dao",
"session",
"get",
"tree",
"entity",
"dao",
"(",
")",
";",
"list",
"<",
"tree",
"entity",
">",
"children",
"new",
"=",
"target",
"dao",
"query",
"tree",
"entity",
"children",
"(",
"id",
")",
";",
"synchronized",
"(",
"this",
")",
"{",
"if",
"(",
"children",
"=",
"=",
"null",
")",
"{",
"children",
"=",
"children",
"new",
";",
"}",
"}",
"}",
"return",
"children",
";",
"}"
] |
[
"delegate",
"the",
"calling",
"to",
"{",
"@",
"link",
"system",
"#",
"load",
"(",
"string",
")",
"}",
"or",
"{",
"@",
"link",
"system",
"#",
"load",
"library",
"(",
"string",
")",
"}"
] |
[
"public",
"static",
"void",
"load",
"library",
"(",
"string",
"lib",
"name",
",",
"boolean",
"absolute",
")",
"{",
"if",
"(",
"absolute",
")",
"{",
"system",
"load",
"(",
"lib",
"name",
")",
";",
"}",
"else",
"{",
"system",
"load",
"library",
"(",
"lib",
"name",
")",
";",
"}",
"}"
] |
[
"creates",
"a",
"new",
"data",
"source",
"supplier",
"with",
"increasing",
"-",
"quality",
"strategy",
"note",
":",
"for",
"performance",
"reasons",
"the",
"list",
"doesn",
"'",
"t",
"get",
"cloned",
",",
"so",
"the",
"caller",
"of",
"this",
"method",
"should",
"not",
"modify",
"the",
"list",
"once",
"passed",
"in",
"here"
] |
[
"public",
"static",
"<",
"t",
">",
"increasing",
"quality",
"data",
"source",
"supplier",
"<",
"t",
">",
"create",
"(",
"list",
"<",
"supplier",
"<",
"data",
"source",
"<",
"t",
">",
">",
">",
"data",
"source",
"suppliers",
")",
"{",
"return",
"create",
"(",
"data",
"source",
"suppliers",
",",
"false",
")",
";",
"}"
] |
[
"a",
"server",
"rst",
"stream",
"shouldn",
"'",
"t",
"prevent",
"the",
"client",
"from",
"consuming",
"the",
"response",
"body"
] |
[
"@",
"test",
"public",
"void",
"server",
"response",
"body",
"rst",
"stream",
"(",
")",
"throws",
"exception",
"{",
"/",
"/",
"write",
"the",
"mocking",
"script",
"peer",
"send",
"frame",
"(",
")",
"settings",
"(",
"new",
"settings",
"(",
")",
")",
";",
"peer",
"accept",
"frame",
"(",
")",
";",
"/",
"/",
"ack",
"peer",
"accept",
"frame",
"(",
")",
";",
"/",
"/",
"syn",
"stream",
"peer",
"accept",
"frame",
"(",
")",
";",
"/",
"/",
"ping",
"peer",
"send",
"frame",
"(",
")",
"headers",
"(",
"false",
",",
"3",
",",
"header",
"entries",
"(",
"\"",
"a",
"\"",
",",
"\"",
"android",
"\"",
")",
")",
";",
"peer",
"send",
"frame",
"(",
")",
"data",
"(",
"true",
",",
"3",
",",
"new",
"buffer",
"(",
")",
"write",
"utf",
"8",
"(",
"\"",
"robot",
"\"",
")",
",",
"5",
")",
";",
"peer",
"send",
"frame",
"(",
")",
"rst",
"stream",
"(",
"3",
",",
"error",
"code",
"no",
"error",
")",
";",
"peer",
"send",
"frame",
"(",
")",
"ping",
"(",
"true",
",",
"await",
"ping",
",",
"0",
")",
";",
"/",
"/",
"pong",
"peer",
"play",
"(",
")",
";",
"/",
"/",
"play",
"it",
"back",
"http",
"2",
"connection",
"connection",
"=",
"connect",
"(",
"peer",
")",
";",
"http",
"2",
"stream",
"stream",
"=",
"connection",
"new",
"stream",
"(",
"header",
"entries",
"(",
")",
",",
"false",
")",
";",
"connection",
"write",
"ping",
"and",
"await",
"pong",
"(",
")",
";",
"assert",
"that",
"(",
"stream",
"take",
"headers",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"headers",
"of",
"(",
"\"",
"a",
"\"",
",",
"\"",
"android",
"\"",
")",
")",
";",
"buffered",
"source",
"source",
"=",
"okio",
"buffer",
"(",
"stream",
"get",
"source",
"(",
")",
")",
";",
"assert",
"that",
"(",
"source",
"read",
"utf",
"8",
"(",
"5",
")",
")",
"is",
"equal",
"to",
"(",
"\"",
"robot",
"\"",
")",
";",
"stream",
"get",
"sink",
"(",
")",
"close",
"(",
")",
";",
"assert",
"that",
"(",
"connection",
"open",
"stream",
"count",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"0",
")",
";",
"/",
"/",
"verify",
"the",
"peer",
"received",
"what",
"was",
"expected",
"in",
"frame",
"syn",
"stream",
"=",
"peer",
"take",
"frame",
"(",
")",
";",
"assert",
"that",
"(",
"syn",
"stream",
"type",
")",
"is",
"equal",
"to",
"(",
"http",
"2",
"type",
"headers",
")",
";",
"in",
"frame",
"ping",
"=",
"peer",
"take",
"frame",
"(",
")",
";",
"assert",
"that",
"(",
"ping",
"type",
")",
"is",
"equal",
"to",
"(",
"http",
"2",
"type",
"ping",
")",
";",
"}"
] |
[
"return",
"the",
"map",
"with",
"version",
"strategies",
"keyed",
"by",
"path",
"pattern"
] |
[
"public",
"map",
"<",
"string",
",",
"version",
"strategy",
">",
"get",
"strategy",
"map",
"(",
")",
"{",
"return",
"this",
"version",
"strategy",
"map",
";",
"}"
] |
[
"returns",
"the",
"width",
"of",
"the",
"grid",
"lines",
"that",
"are",
"drawn",
"away",
"from",
"each",
"axis",
"label"
] |
[
"public",
"float",
"get",
"grid",
"line",
"width",
"(",
")",
"{",
"return",
"m",
"grid",
"line",
"width",
";",
"}"
] |
[
"await",
"the",
"completion",
"of",
"this",
"request"
] |
[
"public",
"void",
"await",
"(",
")",
"throws",
"interrupted",
"exception",
"{",
"latch",
"await",
"(",
")",
";",
"}"
] |
[
"returns",
"the",
"string",
"representation",
"of",
"the",
"current",
"value"
] |
[
"public",
"string",
"to",
"string",
"(",
")",
"{",
"return",
"double",
"to",
"string",
"(",
"get",
"(",
")",
")",
";",
"}"
] |
[
"set",
"action",
"on",
"left"
] |
[
"public",
"void",
"set",
"swipe",
"action",
"left",
"(",
"int",
"swipe",
"action",
"left",
")",
"{",
"touch",
"listener",
"set",
"swipe",
"action",
"left",
"(",
"swipe",
"action",
"left",
")",
";",
"}"
] |
[
"adds",
"condition",
"to",
"check",
"if",
"the",
"index",
"is",
"at",
"least",
"<",
"code",
">",
"age",
"<",
"code",
">",
"old"
] |
[
"public",
"void",
"add",
"max",
"index",
"age",
"condition",
"(",
"time",
"value",
"age",
")",
"{",
"max",
"age",
"condition",
"max",
"age",
"condition",
"=",
"new",
"max",
"age",
"condition",
"(",
"age",
")",
";",
"if",
"(",
"this",
"conditions",
"contains",
"key",
"(",
"max",
"age",
"condition",
"name",
")",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"max",
"age",
"condition",
"name",
"+",
"\"",
"condition",
"is",
"already",
"set",
"\"",
")",
";",
"}",
"this",
"conditions",
"put",
"(",
"max",
"age",
"condition",
"name",
",",
"max",
"age",
"condition",
")",
";",
"}"
] |
[
"add",
"call",
"(",
"consumes",
"2",
"-",
"bytes",
")"
] |
[
"public",
"void",
"add",
"bytes",
"call",
"(",
"string",
"addr",
",",
"string",
"dest",
"addr",
")",
"throws",
"memory",
"access",
"exception",
"{",
"address",
"address",
"=",
"addr",
"(",
"addr",
")",
";",
"address",
"dest",
"=",
"addr",
"(",
"dest",
"addr",
")",
";",
"short",
"rel",
"dest",
"=",
"get",
"short",
"relative",
"offset",
"(",
"address",
",",
"dest",
")",
";",
"add",
"instruction",
"words",
"(",
"address",
",",
"(",
"short",
")",
"(",
"0xf",
"8",
"0",
"0",
"|",
"(",
"rel",
"dest",
"&",
"0x",
"7f",
")",
")",
")",
";",
"/",
"/",
"call",
"rel",
"}"
] |
[
"sets",
"the",
"item",
"at",
"the",
"given",
"index"
] |
[
"public",
"void",
"set",
"(",
"int",
"n",
",",
"int",
"start",
"pc",
",",
"int",
"end",
"pc",
",",
"int",
"handler",
"pc",
",",
"cst",
"type",
"exception",
"class",
")",
"{",
"set",
"0",
"(",
"n",
",",
"new",
"item",
"(",
"start",
"pc",
",",
"end",
"pc",
",",
"handler",
"pc",
",",
"exception",
"class",
")",
")",
";",
"}"
] |
[
"returns",
"the",
"addresses",
"that",
"are",
"in",
"program",
"1",
",",
"but",
"not",
"in",
"program",
"2"
] |
[
"public",
"address",
"set",
"get",
"addresses",
"only",
"in",
"one",
"(",
")",
"{",
"return",
"pgm",
"mem",
"comp",
"get",
"addresses",
"only",
"in",
"one",
"(",
")",
";",
"}"
] |
[
"set",
"the",
"http",
"status",
"code",
"of",
"the",
"response"
] |
[
"boolean",
"set",
"status",
"code",
"(",
"@",
"nullable",
"http",
"status",
"status",
")",
";"
] |
[
"creates",
"a",
"{",
"@",
"code",
"striped",
"<",
"semaphore",
">",
"}",
"with",
"lazily",
"initialized",
",",
"weakly",
"referenced",
"semaphores",
",",
"with",
"the",
"specified",
"number",
"of",
"permits"
] |
[
"public",
"static",
"striped",
"<",
"semaphore",
">",
"lazy",
"weak",
"semaphore",
"(",
"int",
"stripes",
",",
"final",
"int",
"permits",
")",
"{",
"return",
"lazy",
"(",
"stripes",
",",
"new",
"supplier",
"<",
"semaphore",
">",
"(",
")",
"{",
"@",
"override",
"public",
"semaphore",
"get",
"(",
")",
"{",
"return",
"new",
"semaphore",
"(",
"permits",
",",
"false",
")",
";",
"}",
"}",
")",
";",
"}"
] |
[
"set",
"the",
"user",
"data",
"pointer"
] |
[
"public",
"void",
"set",
"user",
"data",
"(",
"object",
"data",
")",
"{",
"m",
"user",
"data",
"=",
"data",
";",
"}"
] |
[
"writes",
"the",
"action",
"cache",
"files",
"to",
"disk",
",",
"reporting",
"any",
"errors",
"that",
"occurred",
"during",
"writing",
"and",
"capturing",
"statistics"
] |
[
"private",
"void",
"save",
"action",
"cache",
"(",
"action",
"cache",
"action",
"cache",
")",
"{",
"action",
"cache",
"statistics",
"builder",
"builder",
"=",
"action",
"cache",
"statistics",
"new",
"builder",
"(",
")",
";",
"action",
"cache",
"merge",
"into",
"action",
"cache",
"statistics",
"(",
"builder",
")",
";",
"auto",
"profiler",
"p",
"=",
"google",
"auto",
"profiler",
"utils",
"profiled",
"and",
"logged",
"(",
"\"",
"saving",
"action",
"cache",
"\"",
",",
"profiler",
"task",
"info",
")",
";",
"try",
"{",
"builder",
"set",
"size",
"in",
"bytes",
"(",
"action",
"cache",
"save",
"(",
")",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"builder",
"set",
"size",
"in",
"bytes",
"(",
"0",
")",
";",
"get",
"reporter",
"(",
")",
"handle",
"(",
"event",
"error",
"(",
"\"",
"i",
"/",
"o",
"error",
"while",
"writing",
"action",
"log",
":",
"\"",
"+",
"e",
"get",
"message",
"(",
")",
")",
")",
";",
"}",
"finally",
"{",
"builder",
"set",
"save",
"time",
"in",
"ms",
"(",
"time",
"unit",
"milliseconds",
"convert",
"(",
"p",
"complete",
"and",
"get",
"elapsed",
"time",
"nanos",
"(",
")",
",",
"time",
"unit",
"nanoseconds",
")",
")",
";",
"}",
"env",
"get",
"event",
"bus",
"(",
")",
"post",
"(",
"builder",
"build",
"(",
")",
")",
";",
"}"
] |
[
"do",
"acquire",
"lock",
"boolean"
] |
[
"protected",
"boolean",
"do",
"acquire",
"lock",
"(",
"connection",
"conn",
",",
"lock",
"d",
"o",
"lock",
"d",
"o",
")",
"{",
"prepared",
"statement",
"ps",
"=",
"null",
";",
"try",
"{",
"/",
"/",
"insert",
"string",
"insert",
"lock",
"s",
"q",
"l",
"=",
"lock",
"store",
"sql",
"factory",
"get",
"log",
"store",
"sql",
"(",
"db",
"type",
")",
"get",
"insert",
"lock",
"s",
"q",
"l",
"(",
"lock",
"table",
")",
";",
"ps",
"=",
"conn",
"prepare",
"statement",
"(",
"insert",
"lock",
"s",
"q",
"l",
")",
";",
"ps",
"set",
"string",
"(",
"1",
",",
"lock",
"d",
"o",
"get",
"xid",
"(",
")",
")",
";",
"ps",
"set",
"long",
"(",
"2",
",",
"lock",
"d",
"o",
"get",
"transaction",
"id",
"(",
")",
")",
";",
"ps",
"set",
"long",
"(",
"3",
",",
"lock",
"d",
"o",
"get",
"branch",
"id",
"(",
")",
")",
";",
"ps",
"set",
"string",
"(",
"4",
",",
"lock",
"d",
"o",
"get",
"resource",
"id",
"(",
")",
")",
";",
"ps",
"set",
"string",
"(",
"5",
",",
"lock",
"d",
"o",
"get",
"table",
"name",
"(",
")",
")",
";",
"ps",
"set",
"string",
"(",
"6",
",",
"lock",
"d",
"o",
"get",
"pk",
"(",
")",
")",
";",
"ps",
"set",
"string",
"(",
"7",
",",
"lock",
"d",
"o",
"get",
"row",
"key",
"(",
")",
")",
";",
"return",
"ps",
"execute",
"update",
"(",
")",
">",
"0",
";",
"}",
"catch",
"(",
"s",
"q",
"l",
"exception",
"e",
")",
"{",
"throw",
"new",
"store",
"exception",
"(",
"e",
")",
";",
"}",
"finally",
"{",
"i",
"o",
"util",
"close",
"(",
"ps",
")",
";",
"}",
"}"
] |
[
"find",
"a",
"method",
"with",
"the",
"given",
"method",
"name",
"and",
"the",
"given",
"parameter",
"types",
",",
"declared",
"on",
"the",
"given",
"class",
"or",
"one",
"of",
"its",
"superclasses",
"will",
"return",
"a",
"public",
",",
"protected",
",",
"package",
"access",
",",
"or",
"private",
"method",
"checks",
"{",
"@",
"code",
"class",
"get",
"declared",
"method",
"}",
",",
"cascading",
"upwards",
"to",
"all",
"superclasses"
] |
[
"public",
"static",
"method",
"find",
"declared",
"method",
"(",
"class",
"<",
"?",
">",
"clazz",
",",
"string",
"method",
"name",
",",
"class",
"<",
"?",
">",
"param",
"types",
")",
"{",
"try",
"{",
"return",
"clazz",
"get",
"declared",
"method",
"(",
"method",
"name",
",",
"param",
"types",
")",
";",
"}",
"catch",
"(",
"no",
"such",
"method",
"exception",
"ex",
")",
"{",
"if",
"(",
"clazz",
"get",
"superclass",
"(",
")",
"!",
"=",
"null",
")",
"{",
"return",
"find",
"declared",
"method",
"(",
"clazz",
"get",
"superclass",
"(",
")",
",",
"method",
"name",
",",
"param",
"types",
")",
";",
"}",
"return",
"null",
";",
"}",
"}"
] |
[
"sets",
"the",
"specified",
"16",
"-",
"bit",
"short",
"integer",
"in",
"the",
"little",
"endian",
"byte",
"order",
"at",
"the",
"current",
"{",
"@",
"code",
"writer",
"index",
"}",
"and",
"increases",
"the",
"{",
"@",
"code",
"writer",
"index",
"}",
"by",
"{",
"@",
"code",
"2",
"}",
"in",
"this",
"buffer",
"the",
"16",
"high",
"-",
"order",
"bits",
"of",
"the",
"specified",
"value",
"are",
"ignored",
"if",
"{",
"@",
"code",
"this",
"writable",
"bytes",
"}",
"is",
"less",
"than",
"{",
"@",
"code",
"2",
"}",
",",
"{",
"@",
"link",
"#",
"ensure",
"writable",
"(",
"int",
")",
"}",
"will",
"be",
"called",
"in",
"an",
"attempt",
"to",
"expand",
"capacity",
"to",
"accommodate"
] |
[
"public",
"abstract",
"byte",
"buf",
"write",
"short",
"l",
"e",
"(",
"int",
"value",
")",
";"
] |
[
"tests",
"that",
"the",
"standalone",
"leader",
"retrieval",
"services",
"return",
"the",
"specified",
"address",
"and",
"the",
"fixed",
"leader",
"session",
"id"
] |
[
"public",
"void",
"test",
"job",
"manager",
"leader",
"retrieval",
"(",
")",
"throws",
"exception",
"{",
"job",
"i",
"d",
"job",
"id",
"1",
"=",
"new",
"job",
"i",
"d",
"(",
")",
";",
"job",
"i",
"d",
"job",
"id",
"2",
"=",
"new",
"job",
"i",
"d",
"(",
")",
";",
"leader",
"retrieval",
"listener",
"jm",
"listener",
"1",
"=",
"mock",
"(",
"leader",
"retrieval",
"listener",
"class",
")",
";",
"leader",
"retrieval",
"listener",
"jm",
"listener",
"2",
"=",
"mock",
"(",
"leader",
"retrieval",
"listener",
"class",
")",
";",
"leader",
"retrieval",
"listener",
"rm",
"listener",
"=",
"mock",
"(",
"leader",
"retrieval",
"listener",
"class",
")",
";",
"leader",
"retrieval",
"service",
"jm",
"leader",
"retrieval",
"service",
"1",
"=",
"standalone",
"ha",
"services",
"get",
"job",
"manager",
"leader",
"retriever",
"(",
"job",
"id",
"1",
")",
";",
"leader",
"retrieval",
"service",
"jm",
"leader",
"retrieval",
"service",
"2",
"=",
"standalone",
"ha",
"services",
"get",
"job",
"manager",
"leader",
"retriever",
"(",
"job",
"id",
"2",
")",
";",
"leader",
"retrieval",
"service",
"rm",
"leader",
"retrieval",
"service",
"=",
"standalone",
"ha",
"services",
"get",
"resource",
"manager",
"leader",
"retriever",
"(",
")",
";",
"jm",
"leader",
"retrieval",
"service",
"1",
"start",
"(",
"jm",
"listener",
"1",
")",
";",
"jm",
"leader",
"retrieval",
"service",
"2",
"start",
"(",
"jm",
"listener",
"2",
")",
";",
"rm",
"leader",
"retrieval",
"service",
"start",
"(",
"rm",
"listener",
")",
";",
"verify",
"(",
"jm",
"listener",
"1",
")",
"notify",
"leader",
"address",
"(",
"eq",
"(",
"\"",
"unknown",
"\"",
")",
",",
"eq",
"(",
"high",
"availability",
"services",
"default",
"leader",
"id",
")",
")",
";",
"verify",
"(",
"jm",
"listener",
"2",
")",
"notify",
"leader",
"address",
"(",
"eq",
"(",
"\"",
"unknown",
"\"",
")",
",",
"eq",
"(",
"high",
"availability",
"services",
"default",
"leader",
"id",
")",
")",
";",
"verify",
"(",
"rm",
"listener",
")",
"notify",
"leader",
"address",
"(",
"eq",
"(",
"resource",
"manager",
"address",
")",
",",
"eq",
"(",
"high",
"availability",
"services",
"default",
"leader",
"id",
")",
")",
";",
"}"
] |
[
"convert",
"a",
"signed",
"long",
"to",
"unsigned",
"by",
"adding",
"2",
"^",
"63",
"to",
"it"
] |
[
"protected",
"static",
"long",
"sortable",
"signed",
"long",
"to",
"unsigned",
"(",
"long",
"value",
")",
"{",
"/",
"/",
"adding",
"2",
"^",
"63",
"or",
"10000000",
"00000000",
"00000000",
"00000000",
"00000000",
"00000000",
"00000000",
"00000000",
"/",
"/",
"equivalent",
"to",
"flipping",
"the",
"first",
"bit",
"return",
"value",
"^",
"mask",
"2",
"63",
";",
"}"
] |
[
"check",
"that",
"this",
"entry",
"point",
"leads",
"to",
"a",
"well",
"behaved",
"subroutine",
",",
"allow",
"it",
"to",
"fall",
"into",
"existing",
"code",
"hit",
"no",
"bad",
"instructions",
"have",
"only",
"one",
"entry",
"point",
"not",
"overlap",
"any",
"existing",
"data",
"or",
"cause",
"offcut",
"references"
] |
[
"public",
"boolean",
"is",
"valid",
"subroutine",
"(",
"address",
"entry",
"point",
",",
"boolean",
"allow",
"existing",
"code",
",",
"boolean",
"must",
"terminate",
")",
"{",
"return",
"check",
"valid",
"subroutine",
"(",
"entry",
"point",
",",
"allow",
"existing",
"code",
",",
"must",
"terminate",
")",
";",
"}"
] |
[
"stop",
"a",
"service",
";",
"if",
"it",
"is",
"null",
"do",
"nothing",
"exceptions",
"are",
"caught",
"and",
"logged",
"at",
"warn",
"level",
"(",
"but",
"not",
"throwables",
")",
"this",
"operation",
"is",
"intended",
"to",
"be",
"used",
"in",
"cleanup",
"operations"
] |
[
"public",
"static",
"exception",
"stop",
"quietly",
"(",
"service",
"service",
")",
"{",
"return",
"stop",
"quietly",
"(",
"log",
",",
"service",
")",
";",
"}"
] |
[
"removes",
"delay",
"markers",
"from",
"unassigned",
"shards",
"based",
"on",
"current",
"time",
"stamp"
] |
[
"private",
"void",
"remove",
"delay",
"markers",
"(",
"routing",
"allocation",
"allocation",
")",
"{",
"final",
"routing",
"nodes",
"unassigned",
"shards",
"unassigned",
"iterator",
"unassigned",
"iterator",
"=",
"allocation",
"routing",
"nodes",
"(",
")",
"unassigned",
"(",
")",
"iterator",
"(",
")",
";",
"final",
"metadata",
"metadata",
"=",
"allocation",
"metadata",
"(",
")",
";",
"while",
"(",
"unassigned",
"iterator",
"has",
"next",
"(",
")",
")",
"{",
"shard",
"routing",
"shard",
"routing",
"=",
"unassigned",
"iterator",
"next",
"(",
")",
";",
"unassigned",
"info",
"unassigned",
"info",
"=",
"shard",
"routing",
"unassigned",
"info",
"(",
")",
";",
"if",
"(",
"unassigned",
"info",
"is",
"delayed",
"(",
")",
")",
"{",
"final",
"long",
"new",
"computed",
"left",
"delay",
"nanos",
"=",
"unassigned",
"info",
"get",
"remaining",
"delay",
"(",
"allocation",
"get",
"current",
"nano",
"time",
"(",
")",
",",
"metadata",
"get",
"index",
"safe",
"(",
"shard",
"routing",
"index",
"(",
")",
")",
"get",
"settings",
"(",
")",
")",
";",
"if",
"(",
"new",
"computed",
"left",
"delay",
"nanos",
"=",
"=",
"0",
")",
"{",
"unassigned",
"iterator",
"update",
"unassigned",
"(",
"new",
"unassigned",
"info",
"(",
"unassigned",
"info",
"get",
"reason",
"(",
")",
",",
"unassigned",
"info",
"get",
"message",
"(",
")",
",",
"unassigned",
"info",
"get",
"failure",
"(",
")",
",",
"unassigned",
"info",
"get",
"num",
"failed",
"allocations",
"(",
")",
",",
"unassigned",
"info",
"get",
"unassigned",
"time",
"in",
"nanos",
"(",
")",
",",
"unassigned",
"info",
"get",
"unassigned",
"time",
"in",
"millis",
"(",
")",
",",
"false",
",",
"unassigned",
"info",
"get",
"last",
"allocation",
"status",
"(",
")",
",",
"unassigned",
"info",
"get",
"failed",
"node",
"ids",
"(",
")",
")",
",",
"shard",
"routing",
"recovery",
"source",
"(",
")",
",",
"allocation",
"changes",
"(",
")",
")",
";",
"}",
"}",
"}",
"}"
] |
[
"sets",
"the",
"preference",
"to",
"execute",
"the",
"search",
"defaults",
"to",
"randomize",
"across",
"shards",
"can",
"be",
"set",
"to",
"{",
"@",
"code",
"local",
"}",
"to",
"prefer",
"local",
"shards",
"or",
"a",
"custom",
"value",
",",
"which",
"guarantees",
"that",
"the",
"same",
"order",
"will",
"be",
"used",
"across",
"different",
"requests"
] |
[
"public",
"get",
"source",
"request",
"preference",
"(",
"string",
"preference",
")",
"{",
"this",
"preference",
"=",
"preference",
";",
"return",
"this",
";",
"}"
] |
[
"generate",
"saml",
"2",
"idp",
"metadata",
"at",
"the",
"specified",
"location"
] |
[
"public",
"void",
"generate",
"(",
"@",
"shell",
"option",
"(",
"value",
"=",
"{",
"\"",
"metadata",
"location",
"\"",
",",
"\"",
"-",
"-",
"metadata",
"location",
"\"",
"}",
",",
"help",
"=",
"\"",
"directory",
"location",
"to",
"hold",
"metadata",
"and",
"relevant",
"keys",
"/",
"certificates",
"\"",
",",
"default",
"value",
"=",
"\"",
"/",
"etc",
"/",
"cas",
"/",
"saml",
"\"",
")",
"final",
"string",
"metadata",
"location",
",",
"@",
"shell",
"option",
"(",
"value",
"=",
"{",
"\"",
"entity",
"id",
"\"",
",",
"\"",
"-",
"-",
"entity",
"id",
"\"",
"}",
",",
"help",
"=",
"\"",
"entity",
"id",
"to",
"use",
"for",
"the",
"generated",
"metadata",
"\"",
",",
"default",
"value",
"=",
"\"",
"cas",
"example",
"org",
"\"",
")",
"final",
"string",
"entity",
"id",
",",
"@",
"shell",
"option",
"(",
"value",
"=",
"{",
"\"",
"host",
"name",
"\"",
",",
"\"",
"-",
"-",
"host",
"name",
"\"",
"}",
",",
"help",
"=",
"\"",
"cas",
"server",
"prefix",
"to",
"be",
"used",
"at",
"the",
"id",
"p",
"host",
"name",
"when",
"generating",
"metadata",
"\"",
",",
"default",
"value",
"=",
"\"",
"https",
":",
"/",
"/",
"cas",
"example",
"org",
"/",
"cas",
"\"",
")",
"final",
"string",
"server",
"prefix",
",",
"@",
"shell",
"option",
"(",
"value",
"=",
"{",
"\"",
"scope",
"\"",
",",
"\"",
"-",
"-",
"scope",
"\"",
"}",
",",
"help",
"=",
"\"",
"scope",
"to",
"use",
"when",
"generating",
"metadata",
"\"",
",",
"default",
"value",
"=",
"\"",
"example",
"org",
"\"",
")",
"final",
"string",
"scope",
",",
"@",
"shell",
"option",
"(",
"value",
"=",
"{",
"\"",
"force",
"\"",
",",
"\"",
"-",
"-",
"force",
"\"",
"}",
",",
"help",
"=",
"\"",
"force",
"metadata",
"generation",
"(",
"xml",
"only",
",",
"not",
"certs",
")",
",",
"overwriting",
"anything",
"at",
"the",
"specified",
"location",
"\"",
")",
"final",
"boolean",
"force",
",",
"@",
"shell",
"option",
"(",
"value",
"=",
"{",
"\"",
"subject",
"alt",
"names",
"\"",
",",
"\"",
"-",
"-",
"subject",
"alt",
"names",
"\"",
"}",
",",
"help",
"=",
"\"",
"comma",
"separated",
"list",
"of",
"other",
"subject",
"alternative",
"names",
"for",
"the",
"certificate",
"(",
"besides",
"entity",
"id",
")",
"\"",
",",
"default",
"value",
"=",
"string",
"utils",
"empty",
")",
"final",
"string",
"subject",
"alt",
"names",
")",
"{",
"val",
"locator",
"=",
"new",
"file",
"system",
"saml",
"id",
"p",
"metadata",
"locator",
"(",
"new",
"file",
"(",
"metadata",
"location",
")",
")",
";",
"val",
"writer",
"=",
"new",
"default",
"saml",
"id",
"p",
"certificate",
"and",
"key",
"writer",
"(",
")",
";",
"writer",
"set",
"hostname",
"(",
"entity",
"id",
")",
";",
"if",
"(",
"string",
"utils",
"is",
"not",
"blank",
"(",
"subject",
"alt",
"names",
")",
")",
"{",
"writer",
"set",
"uri",
"subject",
"alt",
"names",
"(",
"arrays",
"as",
"list",
"(",
"string",
"utils",
"split",
"(",
"subject",
"alt",
"names",
",",
"\"",
",",
"\"",
")",
")",
")",
";",
"}",
"val",
"generate",
"metadata",
"=",
"function",
"utils",
"do",
"if",
"(",
"locator",
"exists",
"(",
"optional",
"empty",
"(",
")",
")",
",",
"(",
")",
"-",
">",
"boolean",
"true",
",",
"(",
")",
"-",
">",
"{",
"logger",
"warn",
"(",
"\"",
"metadata",
"artifacts",
"are",
"available",
"at",
"the",
"specified",
"location",
"[",
"{",
"}",
"]",
"\"",
",",
"metadata",
"location",
")",
";",
"return",
"force",
";",
"}",
")",
"get",
"(",
")",
";",
"if",
"(",
"generate",
"metadata",
")",
"{",
"val",
"props",
"=",
"new",
"cas",
"configuration",
"properties",
"(",
")",
";",
"props",
"get",
"authn",
"(",
")",
"get",
"saml",
"idp",
"(",
")",
"set",
"entity",
"id",
"(",
"entity",
"id",
")",
";",
"props",
"get",
"server",
"(",
")",
"set",
"scope",
"(",
"scope",
")",
";",
"props",
"get",
"server",
"(",
")",
"set",
"prefix",
"(",
"server",
"prefix",
")",
";",
"val",
"context",
"=",
"saml",
"id",
"p",
"metadata",
"generator",
"configuration",
"context",
"builder",
"(",
")",
"saml",
"id",
"p",
"metadata",
"locator",
"(",
"locator",
")",
"saml",
"id",
"p",
"certificate",
"and",
"key",
"writer",
"(",
"writer",
")",
"application",
"context",
"(",
"application",
"context",
")",
"cas",
"properties",
"(",
"props",
")",
"metadata",
"cipher",
"executor",
"(",
"cipher",
"executor",
"no",
"op",
"of",
"string",
"to",
"string",
"(",
")",
")",
"build",
"(",
")",
";",
"val",
"generator",
"=",
"new",
"file",
"system",
"saml",
"id",
"p",
"metadata",
"generator",
"(",
"context",
")",
";",
"generator",
"initialize",
"(",
")",
";",
"generator",
"generate",
"(",
"optional",
"empty",
"(",
")",
")",
";",
"logger",
"info",
"(",
"\"",
"generated",
"metadata",
"is",
"available",
"at",
"[",
"{",
"}",
"]",
"\"",
",",
"locator",
"resolve",
"metadata",
"(",
"optional",
"empty",
"(",
")",
")",
")",
";",
"}",
"else",
"{",
"logger",
"info",
"(",
"\"",
"no",
"metadata",
"was",
"generated",
";",
"it",
"might",
"already",
"exist",
"at",
"the",
"specified",
"path",
"\"",
")",
";",
"}",
"}"
] |
[
"should",
"only",
"be",
"called",
"once",
"when",
"the",
"transport",
"is",
"first",
"established"
] |
[
"void",
"send",
"connection",
"preface",
"and",
"settings",
"(",
")",
"{",
"synchronized",
"(",
"lock",
")",
"{",
"frame",
"writer",
"connection",
"preface",
"(",
")",
";",
"settings",
"settings",
"=",
"new",
"settings",
"(",
")",
";",
"ok",
"http",
"settings",
"util",
"set",
"(",
"settings",
",",
"ok",
"http",
"settings",
"util",
"initial",
"window",
"size",
",",
"initial",
"window",
"size",
")",
";",
"frame",
"writer",
"settings",
"(",
"settings",
")",
";",
"if",
"(",
"initial",
"window",
"size",
">",
"default",
"window",
"size",
")",
"{",
"frame",
"writer",
"window",
"update",
"(",
"utils",
"connection",
"stream",
"id",
",",
"initial",
"window",
"size",
"-",
"default",
"window",
"size",
")",
";",
"}",
"}",
"}"
] |
[
"gets",
"the",
"unit",
"test",
"parameters"
] |
[
"public",
"static",
"stream",
"<",
"arguments",
">",
"get",
"test",
"parameters",
"(",
")",
"{",
"val",
"zero",
"threshold",
"policy",
"=",
"new",
"threshold",
"expired",
"c",
"r",
"l",
"revocation",
"policy",
"(",
"0",
")",
";",
"return",
"stream",
"of",
"(",
"/",
"*",
"*",
"test",
"case",
"#",
"1",
"*",
"valid",
"certificate",
"on",
"valid",
"crl",
"data",
"*",
"/",
"arguments",
"(",
"new",
"resource",
"c",
"r",
"l",
"revocation",
"checker",
"(",
"new",
"class",
"path",
"resource",
"[",
"]",
"{",
"new",
"class",
"path",
"resource",
"(",
"\"",
"user",
"c",
"a",
"-",
"valid",
"crl",
"\"",
")",
",",
"}",
",",
"zero",
"threshold",
"policy",
")",
",",
"new",
"string",
"[",
"]",
"{",
"\"",
"user",
"-",
"valid",
"crt",
"\"",
"}",
",",
"null",
")",
",",
"/",
"*",
"*",
"test",
"case",
"#",
"2",
"*",
"revoked",
"certificate",
"on",
"valid",
"crl",
"data",
"*",
"/",
"arguments",
"(",
"new",
"resource",
"c",
"r",
"l",
"revocation",
"checker",
"(",
"new",
"class",
"path",
"resource",
"[",
"]",
"{",
"new",
"class",
"path",
"resource",
"(",
"\"",
"user",
"c",
"a",
"-",
"valid",
"crl",
"\"",
")",
",",
"new",
"class",
"path",
"resource",
"(",
"\"",
"intermediate",
"c",
"a",
"-",
"valid",
"crl",
"\"",
")",
",",
"new",
"class",
"path",
"resource",
"(",
"\"",
"root",
"c",
"a",
"-",
"valid",
"crl",
"\"",
")",
",",
"}",
",",
"zero",
"threshold",
"policy",
")",
",",
"new",
"string",
"[",
"]",
"{",
"\"",
"user",
"-",
"revoked",
"crt",
"\"",
",",
"\"",
"user",
"c",
"a",
"crt",
"\"",
",",
"\"",
"intermediate",
"c",
"a",
"crt",
"\"",
",",
"\"",
"root",
"c",
"a",
"crt",
"\"",
"}",
",",
"new",
"revoked",
"certificate",
"exception",
"(",
"zoned",
"date",
"time",
"now",
"(",
"zone",
"offset",
"utc",
")",
",",
"new",
"big",
"integer",
"(",
"\"",
"1",
"\"",
")",
")",
")",
",",
"/",
"*",
"*",
"test",
"case",
"#",
"3",
"*",
"valid",
"certificate",
"on",
"expired",
"crl",
"data",
"for",
"head",
"cert",
"*",
"/",
"arguments",
"(",
"new",
"resource",
"c",
"r",
"l",
"revocation",
"checker",
"(",
"new",
"class",
"path",
"resource",
"[",
"]",
"{",
"new",
"class",
"path",
"resource",
"(",
"\"",
"user",
"c",
"a",
"-",
"expired",
"crl",
"\"",
")",
",",
"new",
"class",
"path",
"resource",
"(",
"\"",
"intermediate",
"c",
"a",
"-",
"valid",
"crl",
"\"",
")",
",",
"new",
"class",
"path",
"resource",
"(",
"\"",
"root",
"c",
"a",
"-",
"valid",
"crl",
"\"",
")",
",",
"}",
",",
"zero",
"threshold",
"policy",
")",
",",
"new",
"string",
"[",
"]",
"{",
"\"",
"user",
"-",
"valid",
"crt",
"\"",
",",
"\"",
"user",
"c",
"a",
"crt",
"\"",
",",
"\"",
"intermediate",
"c",
"a",
"crt",
"\"",
",",
"\"",
"root",
"c",
"a",
"crt",
"\"",
"}",
",",
"new",
"expired",
"c",
"r",
"l",
"exception",
"(",
"\"",
"test",
"\"",
",",
"zoned",
"date",
"time",
"now",
"(",
"zone",
"offset",
"utc",
")",
")",
")",
",",
"/",
"*",
"*",
"test",
"case",
"#",
"4",
":",
"valid",
"certificate",
"on",
"expired",
"crl",
"data",
"for",
"intermediate",
"cert",
"*",
"/",
"arguments",
"(",
"new",
"resource",
"c",
"r",
"l",
"revocation",
"checker",
"(",
"new",
"class",
"path",
"resource",
"[",
"]",
"{",
"new",
"class",
"path",
"resource",
"(",
"\"",
"user",
"c",
"a",
"-",
"valid",
"crl",
"\"",
")",
",",
"new",
"class",
"path",
"resource",
"(",
"\"",
"intermediate",
"c",
"a",
"-",
"expired",
"crl",
"\"",
")",
",",
"new",
"class",
"path",
"resource",
"(",
"\"",
"root",
"c",
"a",
"-",
"valid",
"crl",
"\"",
")",
",",
"}",
",",
"zero",
"threshold",
"policy",
")",
",",
"new",
"string",
"[",
"]",
"{",
"\"",
"user",
"-",
"valid",
"crt",
"\"",
",",
"\"",
"user",
"c",
"a",
"crt",
"\"",
",",
"\"",
"intermediate",
"c",
"a",
"crt",
"\"",
",",
"\"",
"root",
"c",
"a",
"crt",
"\"",
"}",
",",
"new",
"expired",
"c",
"r",
"l",
"exception",
"(",
"\"",
"test",
"\"",
",",
"zoned",
"date",
"time",
"now",
"(",
"zone",
"offset",
"utc",
")",
")",
")",
",",
"/",
"*",
"*",
"test",
"case",
"#",
"5",
"*",
"valid",
"certificate",
"on",
"expired",
"crl",
"data",
"with",
"custom",
"expiration",
"*",
"policy",
"to",
"always",
"allow",
"expired",
"crl",
"data",
"*",
"/",
"arguments",
"(",
"new",
"resource",
"c",
"r",
"l",
"revocation",
"checker",
"(",
"new",
"class",
"path",
"resource",
"[",
"]",
"{",
"new",
"class",
"path",
"resource",
"(",
"\"",
"user",
"c",
"a",
"-",
"expired",
"crl",
"\"",
")",
",",
"}",
",",
"crl",
"-",
">",
"{",
"}",
")",
",",
"new",
"string",
"[",
"]",
"{",
"\"",
"user",
"-",
"valid",
"crt",
"\"",
"}",
",",
"null",
")",
")",
";",
"}"
] |
[
"applies",
"the",
"remaining",
"partitions",
"to",
"the",
"table",
"source",
"the",
"{",
"@",
"code",
"remaining",
"partitions",
"}",
"is",
"the",
"remaining",
"partitions",
"of",
"{",
"@",
"link",
"#",
"get",
"partitions",
"(",
")",
"}",
"after",
"partition",
"pruning",
"applied",
"after",
"trying",
"to",
"apply",
"partition",
"pruning",
",",
"we",
"should",
"return",
"a",
"new",
"{",
"@",
"link",
"table",
"source",
"}",
"instance",
"which",
"holds",
"all",
"pruned",
"-",
"partitions"
] |
[
"table",
"source",
"apply",
"partition",
"pruning",
"(",
"list",
"<",
"map",
"<",
"string",
",",
"string",
">",
">",
"remaining",
"partitions",
")",
";"
] |
[
"get",
"array",
"array",
"of",
"model"
] |
[
"public",
"list",
"<",
"list",
"<",
"read",
"only",
"first",
">",
">",
"get",
"array",
"array",
"of",
"model",
"(",
")",
"{",
"return",
"array",
"array",
"of",
"model",
";",
"}"
] |
[
"gets",
"the",
"task",
"status"
] |
[
"public",
"string",
"get",
"task",
"status",
"(",
")",
"{",
"return",
"task",
"status",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"returns",
"the",
"value",
"of",
"a",
"given",
"sequence",
"variable",
"in",
"context",
"of",
"the",
"given",
"variables",
"instance"
] |
[
"protected",
"static",
"list",
"<",
"string",
">",
"get",
"sequence",
"variable",
"value",
"(",
"rule",
"context",
"rule",
"context",
",",
"cc",
"toolchain",
"variables",
"variables",
",",
"string",
"variable",
")",
"throws",
"exception",
"{",
"feature",
"configuration",
"mock",
"feature",
"configuration",
"=",
"build",
"features",
"(",
"rule",
"context",
",",
"\"",
"feature",
"{",
"\"",
",",
"\"",
"name",
":",
"'",
"a",
"'",
"\"",
",",
"\"",
"flag",
"set",
"{",
"\"",
",",
"\"",
"action",
":",
"'",
"foo",
"'",
"\"",
",",
"\"",
"flag",
"group",
"{",
"\"",
",",
"\"",
"iterate",
"over",
":",
"'",
"\"",
"+",
"variable",
"+",
"\"",
"'",
"\"",
",",
"\"",
"flag",
":",
"'",
"%",
"{",
"\"",
"+",
"variable",
"+",
"\"",
"}",
"'",
"\"",
",",
"\"",
"}",
"\"",
",",
"\"",
"}",
"\"",
",",
"\"",
"}",
"\"",
")",
"get",
"feature",
"configuration",
"(",
"immutable",
"set",
"of",
"(",
"\"",
"a",
"\"",
")",
")",
";",
"return",
"mock",
"feature",
"configuration",
"get",
"command",
"line",
"(",
"\"",
"foo",
"\"",
",",
"variables",
")",
";",
"}"
] |
[
"sets",
"the",
"paging",
"parameters"
] |
[
"public",
"void",
"set",
"page",
"params",
"(",
"page",
"params",
"page",
"params",
")",
"{",
"this",
"page",
"params",
"=",
"page",
"params",
";",
"}"
] |
[
"detect",
"duplicate",
"keys",
"in",
"{",
"@",
"link",
"name",
"node",
"#",
"namenode",
"specific",
"keys",
"}"
] |
[
"public",
"void",
"test",
"name",
"node",
"specific",
"keys",
"(",
")",
"{",
"set",
"<",
"string",
">",
"key",
"set",
"=",
"new",
"hash",
"set",
"<",
">",
"(",
")",
";",
"for",
"(",
"string",
"key",
":",
"name",
"node",
"namenode",
"specific",
"keys",
")",
"{",
"assert",
"true",
"(",
"\"",
"duplicate",
"key",
":",
"\"",
"+",
"key",
"+",
"\"",
"in",
"name",
"node",
"namenode",
"specific",
"keys",
"\"",
",",
"key",
"set",
"add",
"(",
"key",
")",
")",
";",
"}",
"}"
] |
[
"returns",
"an",
"array",
"containing",
"all",
"of",
"the",
"elements",
"in",
"the",
"specified",
"collection",
"this",
"method",
"returns",
"the",
"elements",
"in",
"the",
"order",
"they",
"are",
"returned",
"by",
"the",
"collection",
"'",
"s",
"iterator",
"the",
"returned",
"array",
"is",
"\"",
"safe",
"\"",
"in",
"that",
"no",
"references",
"to",
"it",
"are",
"maintained",
"by",
"the",
"collection",
"the",
"caller",
"is",
"thus",
"free",
"to",
"modify",
"the",
"returned",
"array",
"this",
"method",
"assumes",
"that",
"the",
"collection",
"size",
"doesn",
"'",
"t",
"change",
"while",
"the",
"method",
"is",
"running",
"todo",
"(",
"kevinb",
")",
":",
"support",
"concurrently",
"modified",
"collections",
"?"
] |
[
"static",
"object",
"[",
"]",
"to",
"array",
"impl",
"(",
"collection",
"<",
"?",
">",
"c",
")",
"{",
"return",
"fill",
"array",
"(",
"c",
",",
"new",
"object",
"[",
"c",
"size",
"(",
")",
"]",
")",
";",
"}"
] |
[
"get",
"the",
"number",
"of",
"bytes",
"contained",
"in",
"the",
"selection"
] |
[
"public",
"int",
"get",
"byte",
"length",
"(",
")",
"{",
"long",
"diff",
"=",
"end",
"subtract",
"(",
"start",
")",
";",
"return",
"(",
"int",
")",
"(",
"diff",
"+",
"1",
")",
";",
"}"
] |
[
"get",
"enum",
"integer"
] |
[
"public",
"enum",
"integer",
"enum",
"get",
"enum",
"integer",
"(",
")",
"{",
"return",
"enum",
"integer",
";",
"}"
] |
[
"get",
"number",
"item"
] |
[
"public",
"big",
"decimal",
"get",
"number",
"item",
"(",
")",
"{",
"return",
"number",
"item",
";",
"}"
] |
[
"read",
"rule",
"config",
"into",
"{",
"@",
"link",
"alarm",
"rule",
"}"
] |
[
"private",
"void",
"read",
"rules",
"config",
"(",
"rules",
"rules",
")",
"{",
"map",
"rules",
"data",
"=",
"(",
"map",
")",
"yaml",
"data",
"get",
"(",
"\"",
"rules",
"\"",
")",
";",
"if",
"(",
"rules",
"data",
"=",
"=",
"null",
")",
"{",
"return",
";",
"}",
"rules",
"set",
"rules",
"(",
"new",
"array",
"list",
"<",
">",
"(",
")",
")",
";",
"rules",
"data",
"for",
"each",
"(",
"(",
"k",
",",
"v",
")",
"-",
">",
"{",
"if",
"(",
"(",
"(",
"string",
")",
"k",
")",
"ends",
"with",
"(",
"\"",
"rule",
"\"",
")",
")",
"{",
"alarm",
"rule",
"alarm",
"rule",
"=",
"new",
"alarm",
"rule",
"(",
")",
";",
"alarm",
"rule",
"set",
"alarm",
"rule",
"name",
"(",
"(",
"string",
")",
"k",
")",
";",
"map",
"settings",
"=",
"(",
"map",
")",
"v",
";",
"object",
"metrics",
"name",
"=",
"settings",
"get",
"(",
"\"",
"metrics",
"-",
"name",
"\"",
")",
";",
"if",
"(",
"metrics",
"name",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"metrics",
"-",
"name",
"can",
"'",
"t",
"be",
"null",
"\"",
")",
";",
"}",
"alarm",
"rule",
"set",
"metrics",
"name",
"(",
"(",
"string",
")",
"metrics",
"name",
")",
";",
"alarm",
"rule",
"set",
"include",
"names",
"(",
"(",
"array",
"list",
")",
"settings",
"get",
"or",
"default",
"(",
"\"",
"include",
"-",
"names",
"\"",
",",
"new",
"array",
"list",
"(",
"0",
")",
")",
")",
";",
"alarm",
"rule",
"set",
"exclude",
"names",
"(",
"(",
"array",
"list",
")",
"settings",
"get",
"or",
"default",
"(",
"\"",
"exclude",
"-",
"names",
"\"",
",",
"new",
"array",
"list",
"(",
"0",
")",
")",
")",
";",
"alarm",
"rule",
"set",
"include",
"names",
"regex",
"(",
"(",
"string",
")",
"settings",
"get",
"or",
"default",
"(",
"\"",
"include",
"-",
"names",
"-",
"regex",
"\"",
",",
"\"",
"\"",
")",
")",
";",
"alarm",
"rule",
"set",
"exclude",
"names",
"regex",
"(",
"(",
"string",
")",
"settings",
"get",
"or",
"default",
"(",
"\"",
"exclude",
"-",
"names",
"-",
"regex",
"\"",
",",
"\"",
"\"",
")",
")",
";",
"alarm",
"rule",
"set",
"include",
"labels",
"(",
"(",
"array",
"list",
")",
"settings",
"get",
"or",
"default",
"(",
"\"",
"include",
"-",
"labels",
"\"",
",",
"new",
"array",
"list",
"(",
"0",
")",
")",
")",
";",
"alarm",
"rule",
"set",
"exclude",
"labels",
"(",
"(",
"array",
"list",
")",
"settings",
"get",
"or",
"default",
"(",
"\"",
"exclude",
"-",
"labels",
"\"",
",",
"new",
"array",
"list",
"(",
"0",
")",
")",
")",
";",
"alarm",
"rule",
"set",
"include",
"labels",
"regex",
"(",
"(",
"string",
")",
"settings",
"get",
"or",
"default",
"(",
"\"",
"include",
"-",
"labels",
"-",
"regex",
"\"",
",",
"\"",
"\"",
")",
")",
";",
"alarm",
"rule",
"set",
"exclude",
"labels",
"regex",
"(",
"(",
"string",
")",
"settings",
"get",
"or",
"default",
"(",
"\"",
"exclude",
"-",
"labels",
"-",
"regex",
"\"",
",",
"\"",
"\"",
")",
")",
";",
"alarm",
"rule",
"set",
"threshold",
"(",
"settings",
"get",
"(",
"\"",
"threshold",
"\"",
")",
"to",
"string",
"(",
")",
")",
";",
"alarm",
"rule",
"set",
"op",
"(",
"(",
"string",
")",
"settings",
"get",
"(",
"\"",
"op",
"\"",
")",
")",
";",
"alarm",
"rule",
"set",
"period",
"(",
"(",
"integer",
")",
"settings",
"get",
"or",
"default",
"(",
"\"",
"period",
"\"",
",",
"1",
")",
")",
";",
"alarm",
"rule",
"set",
"count",
"(",
"(",
"integer",
")",
"settings",
"get",
"or",
"default",
"(",
"\"",
"count",
"\"",
",",
"1",
")",
")",
";",
"/",
"/",
"how",
"many",
"times",
"of",
"checks",
",",
"the",
"alarm",
"keeps",
"silence",
"after",
"alarm",
"triggered",
",",
"default",
"as",
"same",
"as",
"period",
"alarm",
"rule",
"set",
"silence",
"period",
"(",
"(",
"integer",
")",
"settings",
"get",
"or",
"default",
"(",
"\"",
"silence",
"-",
"period",
"\"",
",",
"alarm",
"rule",
"get",
"period",
"(",
")",
")",
")",
";",
"alarm",
"rule",
"set",
"only",
"as",
"condition",
"(",
"(",
"boolean",
")",
"settings",
"get",
"or",
"default",
"(",
"\"",
"only",
"-",
"as",
"-",
"condition",
"\"",
",",
"false",
")",
")",
";",
"alarm",
"rule",
"set",
"message",
"(",
"(",
"string",
")",
"settings",
"get",
"or",
"default",
"(",
"\"",
"message",
"\"",
",",
"\"",
"alarm",
"caused",
"by",
"rule",
"\"",
"+",
"alarm",
"rule",
"get",
"alarm",
"rule",
"name",
"(",
")",
")",
")",
";",
"rules",
"get",
"rules",
"(",
")",
"add",
"(",
"alarm",
"rule",
")",
";",
"}",
"}",
")",
";",
"}"
] |
[
"configure",
"the",
"{",
"@",
"link",
"destination",
"resolver",
"}",
"to",
"use",
"to",
"resolve",
"string",
"destination",
"names",
"into",
"actual",
"destinations",
"of",
"type",
"{",
"@",
"code",
"<",
"d",
">",
"}",
"this",
"field",
"does",
"not",
"have",
"a",
"default",
"setting",
"if",
"not",
"configured",
",",
"methods",
"that",
"require",
"resolving",
"a",
"destination",
"name",
"will",
"raise",
"an",
"{",
"@",
"link",
"illegal",
"argument",
"exception",
"}"
] |
[
"public",
"void",
"set",
"destination",
"resolver",
"(",
"@",
"nullable",
"destination",
"resolver",
"<",
"d",
">",
"destination",
"resolver",
")",
"{",
"this",
"destination",
"resolver",
"=",
"destination",
"resolver",
";",
"}"
] |
[
"whether",
"to",
"append",
"the",
"query",
"string",
"of",
"the",
"current",
"url",
"to",
"the",
"target",
"redirect",
"url",
"or",
"not",
"by",
"default",
"this",
"is",
"set",
"to",
"{",
"@",
"code",
"false",
"}"
] |
[
"redirect",
"builder",
"propagate",
"query",
"(",
"boolean",
"propagate",
")",
";"
] |
[
"get",
"the",
"number",
"of",
"fixtures"
] |
[
"public",
"int",
"get",
"fixture",
"count",
"(",
")",
"{",
"return",
"fixtures",
"size",
";",
"}"
] |
[
"specify",
"triggered",
"tasks",
"as",
"a",
"map",
"of",
"runnables",
"(",
"the",
"tasks",
")",
"and",
"trigger",
"objects",
"(",
"typically",
"custom",
"implementations",
"of",
"the",
"{",
"@",
"link",
"trigger",
"}",
"interface",
")"
] |
[
"public",
"void",
"set",
"trigger",
"tasks",
"(",
"map",
"<",
"runnable",
",",
"trigger",
">",
"trigger",
"tasks",
")",
"{",
"this",
"trigger",
"tasks",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"trigger",
"tasks",
"for",
"each",
"(",
"(",
"task",
",",
"trigger",
")",
"-",
">",
"add",
"trigger",
"task",
"(",
"new",
"trigger",
"task",
"(",
"task",
",",
"trigger",
")",
")",
")",
";",
"}"
] |
[
"supplies",
"a",
"disabled",
"(",
"no",
"-",
"op",
")",
"data",
"binding",
"context"
] |
[
"public",
"static",
"data",
"binding",
"context",
"get",
"disabled",
"data",
"binding",
"context",
"(",
"android",
"data",
"context",
"ctx",
")",
"{",
"if",
"(",
"ctx",
"use",
"data",
"binding",
"v",
"2",
"(",
")",
")",
"{",
"return",
"disabled",
"v2",
"context",
";",
"}",
"else",
"{",
"return",
"disabled",
"v1",
"context",
";",
"}",
"}"
] |
[
"the",
"\"",
"uwe",
"schindler",
"\"",
"algorithm"
] |
[
"protected",
"void",
"inner",
"check",
"exit",
"(",
"final",
"int",
"status",
")",
"{",
"access",
"controller",
"do",
"privileged",
"(",
"new",
"privileged",
"action",
"<",
"void",
">",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"run",
"(",
")",
"{",
"final",
"string",
"system",
"class",
"name",
"=",
"system",
"class",
"get",
"name",
"(",
")",
",",
"runtime",
"class",
"name",
"=",
"runtime",
"class",
"get",
"name",
"(",
")",
";",
"string",
"exit",
"method",
"hit",
"=",
"null",
";",
"for",
"(",
"final",
"stack",
"trace",
"element",
"se",
":",
"thread",
"current",
"thread",
"(",
")",
"get",
"stack",
"trace",
"(",
")",
")",
"{",
"final",
"string",
"class",
"name",
"=",
"se",
"get",
"class",
"name",
"(",
")",
",",
"method",
"name",
"=",
"se",
"get",
"method",
"name",
"(",
")",
";",
"if",
"(",
"(",
"\"",
"exit",
"\"",
"equals",
"(",
"method",
"name",
")",
"|",
"|",
"\"",
"halt",
"\"",
"equals",
"(",
"method",
"name",
")",
")",
"&",
"&",
"(",
"system",
"class",
"name",
"equals",
"(",
"class",
"name",
")",
"|",
"|",
"runtime",
"class",
"name",
"equals",
"(",
"class",
"name",
")",
")",
")",
"{",
"exit",
"method",
"hit",
"=",
"class",
"name",
"+",
"'",
"#",
"'",
"+",
"method",
"name",
"+",
"'",
"(",
"'",
"+",
"status",
"+",
"'",
")",
"'",
";",
"continue",
";",
"}",
"if",
"(",
"exit",
"method",
"hit",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"classes",
"that",
"can",
"exit",
"=",
"=",
"null",
")",
"{",
"break",
";",
"}",
"if",
"(",
"class",
"can",
"exit",
"(",
"class",
"name",
",",
"classes",
"that",
"can",
"exit",
")",
")",
"{",
"/",
"/",
"this",
"exit",
"point",
"is",
"allowed",
",",
"we",
"return",
"normally",
"from",
"closure",
":",
"return",
"null",
";",
"}",
"/",
"/",
"anything",
"else",
"in",
"stack",
"trace",
"is",
"not",
"allowed",
",",
"break",
"and",
"throw",
"security",
"exception",
"below",
":",
"break",
";",
"}",
"}",
"if",
"(",
"exit",
"method",
"hit",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"should",
"never",
"happen",
",",
"only",
"if",
"jvm",
"hides",
"stack",
"trace",
"-",
"replace",
"by",
"generic",
":",
"exit",
"method",
"hit",
"=",
"\"",
"jvm",
"exit",
"method",
"\"",
";",
"}",
"throw",
"new",
"security",
"exception",
"(",
"exit",
"method",
"hit",
"+",
"\"",
"calls",
"are",
"not",
"allowed",
"\"",
")",
";",
"}",
"}",
")",
";",
"/",
"/",
"we",
"passed",
"the",
"stack",
"check",
",",
"delegate",
"to",
"super",
",",
"so",
"default",
"policy",
"can",
"still",
"deny",
"permission",
":",
"super",
"check",
"exit",
"(",
"status",
")",
";",
"}"
] |
[
"return",
"a",
"{",
"@",
"link",
"resolvable",
"type",
"}",
"for",
"this",
"bean",
"definition",
",",
"either",
"from",
"runtime",
"-",
"cached",
"type",
"information",
"or",
"from",
"configuration",
"-",
"time",
"{",
"@",
"link",
"#",
"set",
"target",
"type",
"(",
"resolvable",
"type",
")",
"}",
"or",
"{",
"@",
"link",
"#",
"set",
"bean",
"class",
"(",
"class",
")",
"}",
",",
"also",
"considering",
"resolved",
"factory",
"method",
"definitions"
] |
[
"public",
"resolvable",
"type",
"get",
"resolvable",
"type",
"(",
")",
"{",
"resolvable",
"type",
"target",
"type",
"=",
"this",
"target",
"type",
";",
"if",
"(",
"target",
"type",
"!",
"=",
"null",
")",
"{",
"return",
"target",
"type",
";",
"}",
"resolvable",
"type",
"return",
"type",
"=",
"this",
"factory",
"method",
"return",
"type",
";",
"if",
"(",
"return",
"type",
"!",
"=",
"null",
")",
"{",
"return",
"return",
"type",
";",
"}",
"method",
"factory",
"method",
"=",
"this",
"factory",
"method",
"to",
"introspect",
";",
"if",
"(",
"factory",
"method",
"!",
"=",
"null",
")",
"{",
"return",
"resolvable",
"type",
"for",
"method",
"return",
"type",
"(",
"factory",
"method",
")",
";",
"}",
"return",
"super",
"get",
"resolvable",
"type",
"(",
")",
";",
"}"
] |
[
"if",
"the",
"playlist",
"is",
"having",
"trouble",
"refreshing",
"the",
"playlist",
"referenced",
"by",
"the",
"given",
"{",
"@",
"link",
"uri",
"}",
",",
"this",
"method",
"throws",
"the",
"underlying",
"error"
] |
[
"void",
"maybe",
"throw",
"playlist",
"refresh",
"error",
"(",
"uri",
"url",
")",
"throws",
"i",
"o",
"exception",
";"
] |
[
"returns",
"a",
"rule",
"transition",
"factory",
"for",
"python",
"binary",
"rules",
"and",
"other",
"rules",
"that",
"may",
"change",
"the",
"python",
"version",
"the",
"factory",
"reads",
"the",
"version",
"specified",
"by",
"the",
"target",
"'",
"s",
"{",
"@",
"code",
"python",
"version",
"}",
"attribute",
"(",
"if",
"given",
")",
",",
"which",
"must",
"exist",
"on",
"the",
"rule",
"class",
"if",
"a",
"value",
"was",
"read",
"successfully",
",",
"the",
"factory",
"returns",
"a",
"transition",
"that",
"sets",
"the",
"version",
"to",
"that",
"value",
"otherwise",
",",
"the",
"factory",
"returns",
"{",
"@",
"code",
"default",
"transition",
"}",
"instead",
"if",
"the",
"attribute",
"has",
"an",
"unparsable",
"value",
",",
"then",
"the",
"factory",
"returns",
"{",
"@",
"code",
"default",
"transition",
"}",
"and",
"it",
"is",
"up",
"to",
"the",
"rule",
"'",
"s",
"analysis",
"phase",
"(",
"{",
"@",
"link",
"py",
"common",
"#",
"validate",
"python",
"version",
"attr",
"}",
")",
"to",
"report",
"an",
"attribute",
"error",
"to",
"the",
"user",
"this",
"case",
"should",
"be",
"prevented",
"by",
"attribute",
"validation",
"if",
"the",
"rule",
"class",
"is",
"defined",
"correctly"
] |
[
"public",
"static",
"transition",
"factory",
"<",
"rule",
">",
"make",
"version",
"transition",
"(",
"python",
"version",
"transition",
"default",
"transition",
")",
"{",
"return",
"(",
"rule",
")",
"-",
">",
"{",
"attribute",
"map",
"attrs",
"=",
"raw",
"attribute",
"mapper",
"of",
"(",
"rule",
")",
";",
"/",
"/",
"fail",
"fast",
"if",
"we",
"'",
"re",
"used",
"on",
"an",
"ill",
"-",
"defined",
"rule",
"class",
"preconditions",
"check",
"argument",
"(",
"attrs",
"has",
"(",
"py",
"common",
"python",
"version",
"attribute",
",",
"type",
"string",
")",
",",
"\"",
"python",
"version",
"transitions",
"require",
"that",
"the",
"rule",
"class",
"define",
"a",
"\"",
"+",
"\"",
"'",
"python",
"version",
"'",
"attribute",
"\"",
")",
";",
"/",
"/",
"attribute",
"validation",
"should",
"enforce",
"that",
"the",
"attribute",
"string",
"value",
"is",
"either",
"a",
"target",
"/",
"/",
"value",
"(",
"\"",
"py2",
"\"",
"or",
"\"",
"py3",
"\"",
")",
"or",
"the",
"sentinel",
"value",
"(",
"\"",
"internal",
"sentinel",
"\"",
")",
"but",
"just",
"in",
"case",
",",
"/",
"/",
"we",
"'",
"ll",
",",
"treat",
"an",
"invalid",
"value",
"as",
"the",
"default",
"value",
"rather",
"than",
"propagate",
"an",
"unchecked",
"/",
"/",
"exception",
"in",
"this",
"context",
"that",
"way",
"the",
"user",
"can",
"at",
"least",
"get",
"a",
"clean",
"error",
"message",
"/",
"/",
"instead",
"of",
"a",
"crash",
"python",
"version",
"transition",
"transition",
";",
"try",
"{",
"python",
"version",
"version",
"from",
"attribute",
"=",
"py",
"common",
"read",
"python",
"version",
"from",
"attribute",
"(",
"attrs",
")",
";",
"if",
"(",
"version",
"from",
"attribute",
"=",
"=",
"null",
")",
"{",
"transition",
"=",
"default",
"transition",
";",
"}",
"else",
"{",
"transition",
"=",
"python",
"version",
"transition",
"to",
"constant",
"(",
"version",
"from",
"attribute",
")",
";",
"}",
"}",
"catch",
"(",
"illegal",
"argument",
"exception",
"ex",
")",
"{",
"transition",
"=",
"default",
"transition",
";",
"}",
"return",
"transition",
";",
"}",
";",
"}"
] |
[
"a",
"collection",
"of",
"customized",
"environments",
"that",
"are",
"attached",
"to",
"the",
"job",
"manager",
"and",
"task",
"manager",
"container",
"(",
"s",
")"
] |
[
"list",
"<",
"map",
"<",
"string",
",",
"string",
">",
">",
"get",
"environments",
"from",
"secrets",
"(",
")",
";"
] |
[
"replaced",
"by",
"{",
"@",
"link",
"#",
"get",
"endpoint",
"dependencies",
"(",
"string",
",",
"duration",
")",
"}"
] |
[
"public",
"topology",
"get",
"endpoint",
"topology",
"(",
"final",
"string",
"endpoint",
"id",
",",
"final",
"duration",
"duration",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"get",
"query",
"service",
"(",
")",
"get",
"endpoint",
"topology",
"(",
"duration",
"get",
"start",
"time",
"bucket",
"(",
")",
",",
"duration",
"get",
"end",
"time",
"bucket",
"(",
")",
",",
"endpoint",
"id",
")",
";",
"}"
] |
[
"return",
"the",
"alias",
"registered",
"for",
"the",
"bean"
] |
[
"public",
"final",
"string",
"get",
"alias",
"(",
")",
"{",
"return",
"this",
"alias",
";",
"}"
] |
[
"test",
"serialization",
"of",
"outer",
"string",
"types"
] |
[
"public",
"void",
"fake",
"outer",
"string",
"serialize",
"(",
"string",
"body",
",",
"handler",
"<",
"async",
"result",
"<",
"string",
">",
">",
"result",
"handler",
")",
"{",
"delegate",
"fake",
"outer",
"string",
"serialize",
"(",
"body",
",",
"result",
"handler",
")",
";",
"}"
] |
[
"implementation",
"of",
"the",
"jca",
"1",
"7",
"{",
"@",
"code",
"#",
"get",
"activation",
"name",
"(",
")",
"}",
"method",
",",
"returning",
"the",
"bean",
"name",
"as",
"set",
"on",
"this",
"message",
"endpoint",
"factory"
] |
[
"public",
"string",
"get",
"activation",
"name",
"(",
")",
"{",
"return",
"this",
"bean",
"name",
";",
"}"
] |
[
"advances",
"the",
"view",
"to",
"the",
"next",
"memory",
"segment",
"the",
"reading",
"will",
"continue",
"after",
"the",
"header",
"of",
"the",
"next",
"segment",
"this",
"method",
"uses",
"{",
"@",
"link",
"#",
"next",
"segment",
"(",
"memory",
"segment",
")",
"}",
"and",
"{",
"@",
"link",
"#",
"get",
"limit",
"for",
"segment",
"(",
"memory",
"segment",
")",
"}",
"to",
"get",
"the",
"next",
"segment",
"and",
"set",
"its",
"limit"
] |
[
"public",
"void",
"advance",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"do",
"advance",
"(",
")",
";",
"}"
] |
[
"indicates",
"whether",
"preemption",
"is",
"disabled",
"on",
"the",
"specified",
"queue"
] |
[
"public",
"boolean",
"get",
"preemption",
"disabled",
"(",
"string",
"queue",
",",
"boolean",
"default",
"val",
")",
"{",
"boolean",
"preemption",
"disabled",
"=",
"get",
"boolean",
"(",
"get",
"queue",
"prefix",
"(",
"queue",
")",
"+",
"queue",
"preemption",
"disabled",
",",
"default",
"val",
")",
";",
"return",
"preemption",
"disabled",
";",
"}"
] |
[
"return",
"a",
"{",
"@",
"code",
"request",
"predicate",
"}",
"that",
"matches",
"if",
"request",
"'",
"s",
"http",
"method",
"is",
"{",
"@",
"code",
"post",
"}",
"and",
"the",
"given",
"{",
"@",
"code",
"pattern",
"}",
"matches",
"against",
"the",
"request",
"path"
] |
[
"public",
"static",
"request",
"predicate",
"post",
"(",
"string",
"pattern",
")",
"{",
"return",
"method",
"(",
"http",
"method",
"post",
")",
"and",
"(",
"path",
"(",
"pattern",
")",
")",
";",
"}"
] |
[
"creates",
"a",
"bitmap",
"from",
"the",
"specified",
"source",
"bitmap",
"it",
"is",
"initialized",
"with",
"the",
"same",
"density",
"as",
"the",
"original",
"bitmap"
] |
[
"public",
"closeable",
"reference",
"<",
"bitmap",
">",
"create",
"bitmap",
"(",
"bitmap",
"source",
")",
"{",
"return",
"create",
"bitmap",
"(",
"source",
",",
"null",
")",
";",
"}"
] |
[
"returns",
"the",
"header",
"names",
"and",
"values",
"as",
"bytes",
"an",
"even",
"numbered",
"index",
"contains",
"the",
"{",
"@",
"code",
"byte",
"[",
"]",
"}",
"representation",
"of",
"a",
"header",
"name",
"(",
"in",
"insertion",
"order",
")",
",",
"and",
"the",
"subsequent",
"odd",
"index",
"number",
"contains",
"the",
"corresponding",
"header",
"value",
"the",
"values",
"of",
"binary",
"headers",
"(",
"with",
"a",
"-",
"bin",
"suffix",
")",
",",
"are",
"already",
"base",
"6",
"4",
"decoded",
"the",
"array",
"may",
"contain",
"several",
"{",
"@",
"code",
"null",
"}",
"values",
"at",
"the",
"end",
"a",
"{",
"@",
"code",
"null",
"}",
"value",
"an",
"index",
"means",
"that",
"all",
"higher",
"numbered",
"indices",
"also",
"contain",
"{",
"@",
"code",
"null",
"}",
"values"
] |
[
"byte",
"[",
"]",
"[",
"]",
"names",
"and",
"values",
"(",
")",
"{",
"return",
"names",
"and",
"values",
";",
"}"
] |
[
"the",
"locality",
"associated",
"with",
"the",
"endpoint",
"a",
"locality",
"corresponds",
"to",
"a",
"failure",
"domain",
"(",
"e",
"g",
",",
"countryregionzone",
")",
"arbitrary",
"failure",
"domain",
"hierarchies",
"can",
"be",
"represented",
"by",
"separating",
"each",
"encapsulating",
"failure",
"domain",
"by",
"for",
"example",
",",
"the",
"locality",
"of",
"an",
"an",
"endpoint",
"in",
"us",
",",
"in",
"us",
"-",
"east",
"-",
"1",
"region",
",",
"within",
"availability",
"zone",
"az",
"-",
"1",
",",
"in",
"data",
"center",
"rack",
"r",
"1",
"1",
"can",
"be",
"represented",
"as",
"usus",
"-",
"east",
"-",
"1az",
"-",
"1r",
"1",
"1",
"istio",
"will",
"configure",
"the",
"sidecar",
"to",
"route",
"to",
"endpoints",
"within",
"the",
"same",
"locality",
"as",
"the",
"sidecar",
"if",
"none",
"of",
"the",
"endpoints",
"in",
"the",
"locality",
"are",
"available",
",",
"endpoints",
"parent",
"locality",
"(",
"but",
"within",
"the",
"same",
"network",
"id",
")",
"will",
"be",
"chosen",
"for",
"example",
",",
"if",
"there",
"are",
"two",
"endpoints",
"in",
"same",
"network",
"(",
"network",
"i",
"d",
"\"",
"n",
"1",
"\"",
")",
",",
"say",
"e",
"1",
"with",
"locality",
"usus",
"-",
"east",
"-",
"1az",
"-",
"1r",
"1",
"1",
"and",
"e",
"2",
"with",
"locality",
"usus",
"-",
"east",
"-",
"1az",
"-",
"2r",
"1",
"2",
",",
"a",
"sidecar",
"from",
"usus",
"-",
"east",
"-",
"1az",
"-",
"1r",
"1",
"1",
"locality",
"will",
"prefer",
"e",
"1",
"from",
"the",
"same",
"locality",
"over",
"e",
"2",
"from",
"a",
"different",
"locality",
"endpoint",
"e",
"2",
"could",
"be",
"the",
"ip",
"associated",
"with",
"a",
"gateway",
"(",
"that",
"bridges",
"networks",
"n",
"1",
"and",
"n",
"2",
")",
",",
"or",
"the",
"ip",
"associated",
"with",
"a",
"standard",
"service",
"endpoint",
"<",
"code",
">",
"string",
"locality",
"=",
"5",
";",
"<",
"code",
">"
] |
[
"public",
"builder",
"clear",
"locality",
"(",
")",
"{",
"locality",
"=",
"get",
"default",
"instance",
"(",
")",
"get",
"locality",
"(",
")",
";",
"on",
"changed",
"(",
")",
";",
"return",
"this",
";",
"}"
] |
[
"creates",
"a",
"file",
"artifact",
"value",
"used",
"as",
"a",
"'",
"proxy",
"'",
"input",
"for",
"other",
"artifact",
"values",
"these",
"are",
"used",
"in",
"{",
"@",
"link",
"action",
"cache",
"checker",
"}"
] |
[
"public",
"static",
"file",
"artifact",
"value",
"create",
"proxy",
"(",
"byte",
"[",
"]",
"digest",
")",
"{",
"preconditions",
"check",
"not",
"null",
"(",
"digest",
")",
";",
"return",
"create",
"for",
"normal",
"file",
"(",
"digest",
",",
"/",
"*",
"proxy",
"=",
"*",
"/",
"null",
",",
"/",
"*",
"size",
"=",
"*",
"/",
"0",
",",
"/",
"*",
"is",
"shareable",
"=",
"*",
"/",
"true",
")",
";",
"}"
] |
[
"converts",
"a",
"long",
"value",
"back",
"to",
"a",
"t"
] |
[
"public",
"t",
"from",
"long",
"(",
"long",
"value",
")",
";"
] |
[
"test",
"merging",
"of",
"a",
"large",
"new",
"window",
"that",
"covers",
"multiple",
"existing",
"windows"
] |
[
"public",
"void",
"test",
"merge",
"large",
"window",
"covering",
"multiple",
"windows",
"(",
")",
"throws",
"exception",
"{",
"@",
"suppress",
"warnings",
"(",
"\"",
"unchecked",
"\"",
")",
"list",
"state",
"<",
"tuple",
"2",
"<",
"time",
"window",
",",
"time",
"window",
">",
">",
"mock",
"state",
"=",
"mock",
"(",
"list",
"state",
"class",
")",
";",
"merging",
"window",
"set",
"<",
"time",
"window",
">",
"window",
"set",
"=",
"new",
"merging",
"window",
"set",
"<",
">",
"(",
"event",
"time",
"session",
"windows",
"with",
"gap",
"(",
"time",
"milliseconds",
"(",
"3",
")",
")",
",",
"mock",
"state",
")",
";",
"testing",
"merge",
"function",
"merge",
"function",
"=",
"new",
"testing",
"merge",
"function",
"(",
")",
";",
"/",
"/",
"add",
"several",
"non",
"-",
"overlapping",
"initial",
"windows",
"merge",
"function",
"reset",
"(",
")",
";",
"assert",
"equals",
"(",
"new",
"time",
"window",
"(",
"1",
",",
"3",
")",
",",
"window",
"set",
"add",
"window",
"(",
"new",
"time",
"window",
"(",
"1",
",",
"3",
")",
",",
"merge",
"function",
")",
")",
";",
"assert",
"false",
"(",
"merge",
"function",
"has",
"merged",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"new",
"time",
"window",
"(",
"1",
",",
"3",
")",
",",
"window",
"set",
"get",
"state",
"window",
"(",
"new",
"time",
"window",
"(",
"1",
",",
"3",
")",
")",
")",
";",
"merge",
"function",
"reset",
"(",
")",
";",
"assert",
"equals",
"(",
"new",
"time",
"window",
"(",
"5",
",",
"8",
")",
",",
"window",
"set",
"add",
"window",
"(",
"new",
"time",
"window",
"(",
"5",
",",
"8",
")",
",",
"merge",
"function",
")",
")",
";",
"assert",
"false",
"(",
"merge",
"function",
"has",
"merged",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"new",
"time",
"window",
"(",
"5",
",",
"8",
")",
",",
"window",
"set",
"get",
"state",
"window",
"(",
"new",
"time",
"window",
"(",
"5",
",",
"8",
")",
")",
")",
";",
"merge",
"function",
"reset",
"(",
")",
";",
"assert",
"equals",
"(",
"new",
"time",
"window",
"(",
"10",
",",
"13",
")",
",",
"window",
"set",
"add",
"window",
"(",
"new",
"time",
"window",
"(",
"10",
",",
"13",
")",
",",
"merge",
"function",
")",
")",
";",
"assert",
"false",
"(",
"merge",
"function",
"has",
"merged",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"new",
"time",
"window",
"(",
"10",
",",
"13",
")",
",",
"window",
"set",
"get",
"state",
"window",
"(",
"new",
"time",
"window",
"(",
"10",
",",
"13",
")",
")",
")",
";",
"/",
"/",
"add",
"a",
"new",
"window",
"that",
"completely",
"covers",
"the",
"existing",
"windows",
"merge",
"function",
"reset",
"(",
")",
";",
"assert",
"equals",
"(",
"new",
"time",
"window",
"(",
"0",
",",
"13",
")",
",",
"window",
"set",
"add",
"window",
"(",
"new",
"time",
"window",
"(",
"0",
",",
"13",
")",
",",
"merge",
"function",
")",
")",
";",
"assert",
"true",
"(",
"merge",
"function",
"has",
"merged",
"(",
")",
")",
";",
"assert",
"that",
"(",
"merge",
"function",
"merged",
"state",
"windows",
"(",
")",
",",
"any",
"of",
"(",
"contains",
"in",
"any",
"order",
"(",
"new",
"time",
"window",
"(",
"0",
",",
"3",
")",
",",
"new",
"time",
"window",
"(",
"5",
",",
"8",
")",
")",
",",
"contains",
"in",
"any",
"order",
"(",
"new",
"time",
"window",
"(",
"0",
",",
"3",
")",
",",
"new",
"time",
"window",
"(",
"10",
",",
"13",
")",
")",
",",
"contains",
"in",
"any",
"order",
"(",
"new",
"time",
"window",
"(",
"5",
",",
"8",
")",
",",
"new",
"time",
"window",
"(",
"10",
",",
"13",
")",
")",
")",
")",
";",
"assert",
"that",
"(",
"window",
"set",
"get",
"state",
"window",
"(",
"new",
"time",
"window",
"(",
"0",
",",
"13",
")",
")",
",",
"any",
"of",
"(",
"is",
"(",
"new",
"time",
"window",
"(",
"1",
",",
"3",
")",
")",
",",
"is",
"(",
"new",
"time",
"window",
"(",
"5",
",",
"8",
")",
")",
",",
"is",
"(",
"new",
"time",
"window",
"(",
"10",
",",
"13",
")",
")",
")",
")",
";",
"}"
] |
[
"set",
"the",
"maximum",
"frequency",
"in",
"which",
"words",
"may",
"still",
"appear",
"words",
"that",
"appear",
"in",
"more",
"than",
"this",
"many",
"docs",
"will",
"be",
"ignored"
] |
[
"public",
"void",
"set",
"max",
"doc",
"freq",
"(",
"int",
"max",
"freq",
")",
"{",
"this",
"max",
"doc",
"freq",
"=",
"max",
"freq",
";",
"}"
] |
[
"sets",
"this",
"dialog",
"to",
"remember",
"its",
"size",
"from",
"one",
"invocation",
"to",
"the",
"next",
"the",
"default",
"is",
"to",
"remember",
"size"
] |
[
"public",
"void",
"set",
"remember",
"size",
"(",
"boolean",
"remember",
"size",
")",
"{",
"this",
"remember",
"size",
"=",
"remember",
"size",
";",
"}"
] |
[
"set",
"max",
"average",
"rt",
"(",
"response",
"time",
")",
"of",
"all",
"passed",
"requests"
] |
[
"public",
"void",
"set",
"avg",
"rt",
"(",
"long",
"avg",
"rt",
")",
"{",
"this",
"avg",
"rt",
"=",
"avg",
"rt",
";",
"}"
] |
[
"the",
"element",
"value",
"was",
"changed"
] |
[
"textarea",
"$",
"onchange",
"(",
"string",
"script",
")",
";"
] |
[
"get",
"just",
"number"
] |
[
"public",
"big",
"decimal",
"get",
"just",
"number",
"(",
")",
"{",
"return",
"just",
"number",
";",
"}"
] |
[
"get",
"map",
"array",
"anytype"
] |
[
"public",
"map",
"<",
"string",
",",
"list",
"<",
"object",
">",
">",
"get",
"map",
"array",
"anytype",
"(",
")",
"{",
"return",
"map",
"array",
"anytype",
";",
"}"
] |
[
"get",
"the",
"version",
"of",
"the",
"connect",
"protocol",
"that",
"is",
"currently",
"active",
"in",
"the",
"group",
"of",
"workers"
] |
[
"public",
"short",
"current",
"protocol",
"version",
"(",
")",
"{",
"return",
"coordinator",
"current",
"protocol",
"version",
"(",
")",
";",
"}"
] |
[
"get",
"small",
"snake"
] |
[
"public",
"string",
"get",
"small",
"snake",
"(",
")",
"{",
"return",
"small",
"snake",
";",
"}"
] |
[
"retrieve",
"a",
"list",
"of",
"stop",
"low",
"disks",
"i",
"e",
"disks",
"with",
"the",
"highest",
"max",
"latencies"
] |
[
"private",
"array",
"list",
"<",
"disk",
"latency",
">",
"get",
"slow",
"disks",
"(",
"map",
"<",
"string",
",",
"disk",
"latency",
">",
"reports",
",",
"int",
"num",
"disks",
",",
"long",
"now",
")",
"{",
"if",
"(",
"reports",
"is",
"empty",
"(",
")",
")",
"{",
"return",
"new",
"array",
"list",
"(",
"immutable",
"list",
"of",
"(",
")",
")",
";",
"}",
"final",
"priority",
"queue",
"<",
"disk",
"latency",
">",
"top",
"n",
"reports",
"=",
"new",
"priority",
"queue",
"<",
">",
"(",
"reports",
"size",
"(",
")",
",",
"new",
"comparator",
"<",
"disk",
"latency",
">",
"(",
")",
"{",
"@",
"override",
"public",
"int",
"compare",
"(",
"disk",
"latency",
"o",
"1",
",",
"disk",
"latency",
"o",
"2",
")",
"{",
"return",
"doubles",
"compare",
"(",
"o",
"1",
"get",
"max",
"latency",
"(",
")",
",",
"o",
"2",
"get",
"max",
"latency",
"(",
")",
")",
";",
"}",
"}",
")",
";",
"array",
"list",
"<",
"disk",
"latency",
">",
"old",
"slow",
"disk",
"i",
"ds",
"=",
"lists",
"new",
"array",
"list",
"(",
")",
";",
"for",
"(",
"map",
"entry",
"<",
"string",
",",
"disk",
"latency",
">",
"entry",
":",
"reports",
"entry",
"set",
"(",
")",
")",
"{",
"disk",
"latency",
"disk",
"latency",
"=",
"entry",
"get",
"value",
"(",
")",
";",
"if",
"(",
"now",
"-",
"disk",
"latency",
"timestamp",
"<",
"report",
"validity",
"ms",
")",
"{",
"if",
"(",
"top",
"n",
"reports",
"size",
"(",
")",
"<",
"num",
"disks",
")",
"{",
"top",
"n",
"reports",
"add",
"(",
"disk",
"latency",
")",
";",
"}",
"else",
"if",
"(",
"top",
"n",
"reports",
"peek",
"(",
")",
"get",
"max",
"latency",
"(",
")",
"<",
"disk",
"latency",
"get",
"max",
"latency",
"(",
")",
")",
"{",
"top",
"n",
"reports",
"poll",
"(",
")",
";",
"top",
"n",
"reports",
"add",
"(",
"disk",
"latency",
")",
";",
"}",
"}",
"else",
"{",
"old",
"slow",
"disk",
"i",
"ds",
"add",
"(",
"disk",
"latency",
")",
";",
"}",
"}",
"old",
"slow",
"disks",
"check",
"=",
"old",
"slow",
"disk",
"i",
"ds",
";",
"return",
"lists",
"new",
"array",
"list",
"(",
"top",
"n",
"reports",
")",
";",
"}"
] |
[
"register",
"a",
"prototype",
"bean",
"with",
"the",
"underlying",
"bean",
"factory",
"for",
"more",
"advanced",
"needs",
",",
"register",
"with",
"the",
"underlying",
"bean",
"factory",
"directly"
] |
[
"public",
"void",
"register",
"prototype",
"(",
"string",
"name",
",",
"class",
"<",
"?",
">",
"clazz",
")",
"throws",
"beans",
"exception",
"{",
"generic",
"bean",
"definition",
"bd",
"=",
"new",
"generic",
"bean",
"definition",
"(",
")",
";",
"bd",
"set",
"scope",
"(",
"bean",
"definition",
"scope",
"prototype",
")",
";",
"bd",
"set",
"bean",
"class",
"(",
"clazz",
")",
";",
"get",
"default",
"listable",
"bean",
"factory",
"(",
")",
"register",
"bean",
"definition",
"(",
"name",
",",
"bd",
")",
";",
"}"
] |
[
"put",
"bitmap",
"in",
"cache"
] |
[
"public",
"void",
"put",
"(",
"@",
"non",
"null",
"final",
"string",
"key",
",",
"final",
"bitmap",
"value",
")",
"{",
"put",
"(",
"key",
",",
"value",
",",
"-",
"1",
")",
";",
"}"
] |
[
"selects",
"an",
"album",
"by",
"the",
"given",
"album",
"title"
] |
[
"public",
"album",
"page",
"select",
"album",
"(",
"string",
"album",
"title",
")",
"{",
"/",
"/",
"uses",
"x",
"path",
"to",
"find",
"list",
"of",
"html",
"anchor",
"tags",
"with",
"the",
"class",
"album",
"in",
"it",
"var",
"album",
"links",
"=",
"(",
"list",
"<",
"html",
"anchor",
">",
")",
"page",
"get",
"by",
"x",
"path",
"(",
"\"",
"/",
"/",
"tr",
"[",
"@",
"class",
"=",
"'",
"album",
"'",
"]",
"/",
"/",
"a",
"\"",
")",
";",
"for",
"(",
"var",
"anchor",
":",
"album",
"links",
")",
"{",
"if",
"(",
"anchor",
"get",
"text",
"content",
"(",
")",
"equals",
"(",
"album",
"title",
")",
")",
"{",
"try",
"{",
"anchor",
"click",
"(",
")",
";",
"return",
"new",
"album",
"page",
"(",
"web",
"client",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"e",
"print",
"stack",
"trace",
"(",
")",
";",
"}",
"}",
"}",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"no",
"links",
"with",
"the",
"album",
"title",
":",
"\"",
"+",
"album",
"title",
")",
";",
"}"
] |
[
"extract",
"a",
"date",
"from",
"a",
"string",
",",
"defaulting",
"to",
"yy",
"-",
"mm",
"-",
"dd",
"order",
"for",
"all",
"-",
"numeric",
"strings"
] |
[
"public",
"static",
"final",
"calendar",
"parse",
"(",
"string",
"date",
"str",
")",
"throws",
"calendar",
"parser",
"exception",
"{",
"return",
"parse",
"(",
"date",
"str",
",",
"yy",
"mm",
"dd",
")",
";",
"}"
] |
[
"get",
"the",
"public",
"resource",
"url",
"for",
"the",
"given",
"uri",
"string",
"the",
"uri",
"string",
"is",
"expected",
"to",
"be",
"a",
"path",
"and",
"if",
"it",
"contains",
"a",
"query",
"or",
"fragment",
"those",
"will",
"be",
"preserved",
"in",
"the",
"resulting",
"public",
"resource",
"url"
] |
[
"public",
"final",
"mono",
"<",
"string",
">",
"get",
"for",
"uri",
"string",
"(",
"string",
"uri",
"string",
",",
"server",
"web",
"exchange",
"exchange",
")",
"{",
"server",
"http",
"request",
"request",
"=",
"exchange",
"get",
"request",
"(",
")",
";",
"int",
"query",
"index",
"=",
"get",
"query",
"index",
"(",
"uri",
"string",
")",
";",
"string",
"lookup",
"path",
"=",
"uri",
"string",
"substring",
"(",
"0",
",",
"query",
"index",
")",
";",
"string",
"query",
"=",
"uri",
"string",
"substring",
"(",
"query",
"index",
")",
";",
"path",
"container",
"parsed",
"lookup",
"path",
"=",
"path",
"container",
"parse",
"path",
"(",
"lookup",
"path",
")",
";",
"return",
"resolve",
"resource",
"url",
"(",
"exchange",
",",
"parsed",
"lookup",
"path",
")",
"map",
"(",
"resolved",
"path",
"-",
">",
"request",
"get",
"path",
"(",
")",
"context",
"path",
"(",
")",
"value",
"(",
")",
"+",
"resolved",
"path",
"+",
"query",
")",
";",
"}"
] |
[
"returns",
"the",
"'",
"double",
"'",
"value",
"at",
"the",
"specified",
"address",
"in",
"memory"
] |
[
"public",
"final",
"double",
"get",
"double",
"(",
"address",
"address",
")",
"throws",
"memory",
"access",
"exception",
"{",
"long",
"bits",
"=",
"current",
"program",
"get",
"memory",
"(",
")",
"get",
"long",
"(",
"address",
")",
";",
"return",
"double",
"long",
"bits",
"to",
"double",
"(",
"bits",
")",
";",
"}"
] |
[
"returns",
"library",
"'",
"s",
"path",
"name"
] |
[
"public",
"string",
"get",
"library",
"name",
"(",
")",
"{",
"return",
"name",
"get",
"string",
"(",
")",
";",
"}"
] |
[
"inserts",
"the",
"specified",
"element",
"into",
"this",
"priority",
"queue",
"as",
"the",
"queue",
"is",
"unbounded",
"this",
"method",
"will",
"never",
"block"
] |
[
"public",
"boolean",
"offer",
"(",
"e",
"e",
",",
"long",
"timeout",
",",
"time",
"unit",
"unit",
")",
"{",
"check",
"not",
"null",
"(",
"unit",
")",
";",
"return",
"offer",
"(",
"e",
")",
";",
"/",
"/",
"never",
"need",
"to",
"block",
"}"
] |
[
"get",
"attribute",
"integer"
] |
[
"public",
"integer",
"get",
"attribute",
"integer",
"(",
")",
"{",
"return",
"attribute",
"integer",
";",
"}"
] |
[
"allocate",
"a",
"direct",
"{",
"@",
"link",
"byte",
"buf",
"}",
"with",
"the",
"given",
"initial",
"capacity"
] |
[
"byte",
"buf",
"direct",
"buffer",
"(",
"int",
"initial",
"capacity",
")",
";"
] |
[
"determines",
"whether",
"{",
"@",
"code",
"specifier",
"}",
"represents",
"a",
"valid",
"{",
"@",
"link",
"host",
"specifier",
"}",
"as",
"described",
"in",
"the",
"documentation",
"for",
"{",
"@",
"link",
"#",
"from",
"valid",
"(",
"string",
")",
"}"
] |
[
"public",
"static",
"boolean",
"is",
"valid",
"(",
"string",
"specifier",
")",
"{",
"try",
"{",
"from",
"valid",
"(",
"specifier",
")",
";",
"return",
"true",
";",
"}",
"catch",
"(",
"illegal",
"argument",
"exception",
"e",
")",
"{",
"return",
"false",
";",
"}",
"}"
] |
[
"set",
"the",
"number",
"of",
"available",
"processors"
] |
[
"synchronized",
"void",
"set",
"available",
"processors",
"(",
"final",
"int",
"available",
"processors",
")",
"{",
"object",
"util",
"check",
"positive",
"(",
"available",
"processors",
",",
"\"",
"available",
"processors",
"\"",
")",
";",
"if",
"(",
"this",
"available",
"processors",
"!",
"=",
"0",
")",
"{",
"final",
"string",
"message",
"=",
"string",
"format",
"(",
"locale",
"root",
",",
"\"",
"available",
"processors",
"is",
"already",
"set",
"to",
"[",
"%",
"d",
"]",
",",
"rejecting",
"[",
"%",
"d",
"]",
"\"",
",",
"this",
"available",
"processors",
",",
"available",
"processors",
")",
";",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"message",
")",
";",
"}",
"this",
"available",
"processors",
"=",
"available",
"processors",
";",
"}"
] |
[
"build",
"a",
"{",
"@",
"code",
"resolvable",
"method",
"}",
"from",
"the",
"provided",
"filters",
"which",
"must",
"resolve",
"to",
"a",
"unique",
",",
"single",
"method",
"see",
"additional",
"resolve",
"xxx",
"shortcut",
"methods",
"going",
"directly",
"to",
"{",
"@",
"link",
"method",
"}",
"or",
"return",
"type",
"parameter"
] |
[
"public",
"resolvable",
"method",
"build",
"(",
")",
"{",
"set",
"<",
"method",
">",
"methods",
"=",
"method",
"introspector",
"select",
"methods",
"(",
"this",
"object",
"class",
",",
"this",
":",
":",
"is",
"match",
")",
";",
"assert",
"state",
"(",
"!",
"methods",
"is",
"empty",
"(",
")",
",",
"(",
")",
"-",
">",
"\"",
"no",
"matching",
"method",
":",
"\"",
"+",
"this",
")",
";",
"assert",
"state",
"(",
"methods",
"size",
"(",
")",
"=",
"=",
"1",
",",
"(",
")",
"-",
">",
"\"",
"multiple",
"matching",
"methods",
":",
"\"",
"+",
"this",
"+",
"format",
"methods",
"(",
"methods",
")",
")",
";",
"return",
"new",
"resolvable",
"method",
"(",
"methods",
"iterator",
"(",
")",
"next",
"(",
")",
")",
";",
"}"
] |
[
"adds",
"the",
"specified",
"delay",
"to",
"all",
"tasks"
] |
[
"public",
"synchronized",
"void",
"delay",
"(",
"long",
"delay",
"millis",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
",",
"n",
"=",
"tasks",
"size",
";",
"i",
"<",
"n",
";",
"i",
"+",
"+",
")",
"{",
"task",
"task",
"=",
"tasks",
"get",
"(",
"i",
")",
";",
"synchronized",
"(",
"task",
")",
"{",
"task",
"execute",
"time",
"millis",
"+",
"=",
"delay",
"millis",
";",
"}",
"}",
"}"
] |
[
"returns",
"the",
"timestamp",
"associated",
"with",
"this",
"{",
"@",
"link",
"watermark",
"}",
"in",
"milliseconds"
] |
[
"public",
"long",
"get",
"timestamp",
"(",
")",
"{",
"return",
"timestamp",
";",
"}"
] |
[
"gets",
"error",
"description",
"from"
] |
[
"protected",
"string",
"get",
"error",
"description",
"from",
"(",
"final",
"map",
"<",
"string",
",",
"object",
">",
"model",
")",
"{",
"return",
"model",
"get",
"(",
"cas",
"view",
"constants",
"model",
"attribute",
"name",
"error",
"description",
")",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"register",
"a",
"listener",
"that",
"will",
"be",
"called",
"when",
"this",
"model",
"is",
"unbound",
"from",
"a",
"view",
"the",
"listener",
"will",
"contribute",
"to",
"this",
"model",
"'",
"s",
"hash",
"code",
"state",
"per",
"the",
"{",
"@",
"link",
"com",
"airbnb",
"epoxy",
"epoxy",
"attribute",
"option",
"#",
"do",
"not",
"hash",
"}",
"rules",
"you",
"may",
"clear",
"the",
"listener",
"by",
"setting",
"a",
"null",
"value",
",",
"or",
"by",
"calling",
"{",
"@",
"link",
"#",
"reset",
"(",
")",
"}"
] |
[
"public",
"prop",
"defaults",
"view",
"model",
"on",
"unbind",
"(",
"on",
"model",
"unbound",
"listener",
"<",
"prop",
"defaults",
"view",
"model",
",",
"prop",
"defaults",
"view",
">",
"listener",
")",
"{",
"on",
"mutation",
"(",
")",
";",
"this",
"on",
"model",
"unbound",
"listener",
"epoxy",
"generated",
"model",
"=",
"listener",
";",
"return",
"this",
";",
"}"
] |
[
"test",
"of",
"get",
"task",
"type",
"method",
",",
"of",
"class",
"task",
"i",
"d"
] |
[
"public",
"void",
"test",
"get",
"task",
"type",
"char",
"(",
")",
"{",
"assert",
"equals",
"(",
"\"",
"the",
"get",
"task",
"type",
"(",
")",
"method",
"did",
"not",
"return",
"the",
"expected",
"type",
"\"",
",",
"task",
"type",
"map",
",",
"task",
"i",
"d",
"get",
"task",
"type",
"(",
"'",
"m",
"'",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"the",
"get",
"task",
"type",
"(",
")",
"method",
"did",
"not",
"return",
"the",
"expected",
"type",
"\"",
",",
"task",
"type",
"reduce",
",",
"task",
"i",
"d",
"get",
"task",
"type",
"(",
"'",
"r",
"'",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"the",
"get",
"task",
"type",
"(",
")",
"method",
"did",
"not",
"return",
"the",
"expected",
"type",
"\"",
",",
"task",
"type",
"job",
"setup",
",",
"task",
"i",
"d",
"get",
"task",
"type",
"(",
"'",
"s",
"'",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"the",
"get",
"task",
"type",
"(",
")",
"method",
"did",
"not",
"return",
"the",
"expected",
"type",
"\"",
",",
"task",
"type",
"job",
"cleanup",
",",
"task",
"i",
"d",
"get",
"task",
"type",
"(",
"'",
"c",
"'",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"the",
"get",
"task",
"type",
"(",
")",
"method",
"did",
"not",
"return",
"the",
"expected",
"type",
"\"",
",",
"task",
"type",
"task",
"cleanup",
",",
"task",
"i",
"d",
"get",
"task",
"type",
"(",
"'",
"t",
"'",
")",
")",
";",
"assert",
"null",
"(",
"\"",
"the",
"get",
"task",
"type",
"(",
")",
"method",
"did",
"not",
"return",
"null",
"for",
"an",
"unknown",
"\"",
"+",
"\"",
"type",
"\"",
",",
"task",
"i",
"d",
"get",
"task",
"type",
"(",
"'",
"x",
"'",
")",
")",
";",
"}"
] |
[
"performs",
"constraint",
"checking",
"on",
"the",
"given",
"rule",
"'",
"s",
"dependencies",
"and",
"reports",
"any",
"errors",
"this",
"includes",
":",
"static",
"environment",
"checking",
":",
"if",
"this",
"rule",
"supports",
"environment",
"e",
",",
"all",
"deps",
"outside",
"selects",
"must",
"also",
"support",
"e",
"refined",
"environment",
"computation",
":",
"this",
"rule",
"'",
"s",
"refined",
"environments",
"are",
"its",
"static",
"environments",
"intersected",
"with",
"the",
"refined",
"environments",
"of",
"all",
"dependencies",
"(",
"including",
"chosen",
"deps",
"in",
"selects",
")",
"refined",
"environment",
"checking",
":",
"no",
"environment",
"groups",
"can",
"be",
"\"",
"emptied",
"\"",
"due",
"to",
"refinement"
] |
[
"void",
"check",
"constraints",
"(",
"t",
"context",
",",
"environment",
"collection",
"static",
"environments",
",",
"environment",
"collection",
"builder",
"refined",
"environments",
",",
"map",
"<",
"label",
",",
"removed",
"environment",
"culprit",
">",
"removed",
"environment",
"culprits",
")",
";"
] |
[
"validates",
"the",
"given",
"ghidra",
"installation",
"directory"
] |
[
"public",
"static",
"void",
"validate",
"ghidra",
"installation",
"(",
"file",
"ghidra",
"install",
"dir",
")",
"throws",
"i",
"o",
"exception",
"{",
"application",
"layout",
"layout",
";",
"try",
"{",
"layout",
"=",
"new",
"ghidra",
"application",
"layout",
"(",
"ghidra",
"install",
"dir",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"not",
"a",
"valid",
"ghidra",
"installation",
"\"",
")",
";",
"}",
"application",
"properties",
"application",
"properties",
"=",
"layout",
"get",
"application",
"properties",
"(",
")",
";",
"application",
"version",
"version",
";",
"try",
"{",
"version",
"=",
"new",
"application",
"version",
"(",
"application",
"properties",
"get",
"application",
"version",
"(",
")",
")",
";",
"}",
"catch",
"(",
"illegal",
"argument",
"exception",
"e",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"error",
"parsing",
"application",
"version",
"\"",
"+",
"e",
"get",
"message",
"(",
")",
"+",
"\"",
"\"",
")",
";",
"}",
"if",
"(",
"version",
"compare",
"to",
"(",
"min",
"ghidra",
"version",
")",
"<",
"0",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"ghidra",
"installation",
"must",
"be",
"version",
"\"",
"+",
"min",
"ghidra",
"version",
"+",
"\"",
"or",
"later",
"\"",
")",
";",
"}",
"string",
"layout",
"version",
"=",
"application",
"properties",
"get",
"property",
"(",
"application",
"properties",
"application",
"layout",
"version",
"property",
")",
";",
"if",
"(",
"layout",
"version",
"=",
"=",
"null",
"|",
"|",
"!",
"layout",
"version",
"equals",
"(",
"\"",
"1",
"\"",
")",
")",
"{",
"/",
"/",
"we",
"can",
"be",
"smarter",
"about",
"this",
"check",
"and",
"what",
"we",
"support",
"later",
",",
"once",
"the",
"layout",
"version",
"/",
"/",
"actually",
"changes",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"ghidra",
"application",
"layout",
"is",
"not",
"supported",
"please",
"upgrade",
"\"",
"+",
"activator",
"plugin",
"id",
"+",
"\"",
"to",
"use",
"this",
"version",
"of",
"ghidra",
"\"",
")",
";",
"}",
"}"
] |
[
"defines",
"the",
"size",
"of",
"a",
"long",
"primitive",
"data",
"type"
] |
[
"public",
"void",
"set",
"long",
"size",
"(",
"int",
"long",
"size",
")",
"{",
"this",
"long",
"size",
"=",
"long",
"size",
";",
"if",
"(",
"long",
"long",
"size",
"<",
"long",
"size",
")",
"{",
"set",
"long",
"long",
"size",
"(",
"long",
"size",
")",
";",
"}",
"if",
"(",
"integer",
"size",
">",
"long",
"size",
")",
"{",
"set",
"integer",
"size",
"(",
"long",
"size",
")",
";",
"}",
"}"
] |
[
"returns",
"a",
"{",
"@",
"code",
"multimap",
"}",
"with",
"the",
"specified",
"implementation",
",",
"initialized",
"with",
"the",
"entries",
"of",
"{",
"@",
"code",
"multimap",
"}"
] |
[
"public",
"<",
"k",
"extends",
"k0",
",",
"v",
"extends",
"v0",
">",
"multimap",
"<",
"k",
",",
"v",
">",
"build",
"(",
"multimap",
"<",
"?",
"extends",
"k",
",",
"?",
"extends",
"v",
">",
"multimap",
")",
"{",
"multimap",
"<",
"k",
",",
"v",
">",
"result",
"=",
"build",
"(",
")",
";",
"result",
"put",
"all",
"(",
"multimap",
")",
";",
"return",
"result",
";",
"}"
] |
[
"converts",
"{",
"@",
"link",
"reader",
"}",
"to",
"given",
"type"
] |
[
"public",
"static",
"<",
"t",
">",
"t",
"from",
"json",
"(",
"@",
"non",
"null",
"final",
"reader",
"reader",
",",
"@",
"non",
"null",
"final",
"type",
"type",
")",
"{",
"return",
"from",
"json",
"(",
"get",
"gson",
"(",
")",
",",
"reader",
",",
"type",
")",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.