docstring_tokens
list | code_tokens
list |
|---|---|
[
"set",
"the",
"username",
"of",
"the",
"user",
"that",
"should",
"enabled",
"or",
"disabled",
"must",
"not",
"be",
"{",
"@",
"code",
"null",
"}"
] |
[
"public",
"set",
"enabled",
"request",
"builder",
"username",
"(",
"string",
"username",
")",
"{",
"request",
"username",
"(",
"username",
")",
";",
"return",
"this",
";",
"}"
] |
[
"extract",
"alias",
"(",
"or",
"source",
"table",
"name",
")",
"for",
"specified",
"constraint",
"from",
"sql",
"select",
"searches",
"in",
"from",
"and",
"join"
] |
[
"public",
"static",
"table",
"get",
"constraint",
"table",
"(",
"plain",
"select",
"select",
",",
"d",
"b",
"d",
"attribute",
"constraint",
"constraint",
")",
"{",
"string",
"constr",
"table",
";",
"d",
"b",
"s",
"attribute",
"base",
"ca",
"=",
"constraint",
"get",
"attribute",
"(",
")",
";",
"if",
"(",
"ca",
"instanceof",
"d",
"b",
"d",
"attribute",
"binding",
")",
"{",
"constr",
"table",
"=",
"(",
"(",
"d",
"b",
"d",
"attribute",
"binding",
")",
"ca",
")",
"get",
"meta",
"attribute",
"(",
")",
"get",
"entity",
"name",
"(",
")",
";",
"}",
"else",
"if",
"(",
"ca",
"instanceof",
"d",
"b",
"s",
"entity",
"attribute",
")",
"{",
"constr",
"table",
"=",
"(",
"(",
"d",
"b",
"s",
"entity",
"attribute",
")",
"ca",
")",
"get",
"parent",
"object",
"(",
")",
"get",
"name",
"(",
")",
";",
"}",
"else",
"{",
"return",
"null",
";",
"}",
"if",
"(",
"constr",
"table",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"from",
"item",
"from",
"item",
"=",
"select",
"get",
"from",
"item",
"(",
")",
";",
"table",
"table",
"=",
"find",
"table",
"in",
"from",
"(",
"from",
"item",
",",
"constr",
"table",
")",
";",
"if",
"(",
"table",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"maybe",
"it",
"is",
"a",
"join",
"if",
"(",
"!",
"common",
"utils",
"is",
"empty",
"(",
"select",
"get",
"joins",
"(",
")",
")",
")",
"{",
"for",
"(",
"join",
"join",
":",
"select",
"get",
"joins",
"(",
")",
")",
"{",
"table",
"=",
"find",
"table",
"in",
"from",
"(",
"join",
"get",
"right",
"item",
"(",
")",
",",
"constr",
"table",
")",
";",
"if",
"(",
"table",
"!",
"=",
"null",
")",
"{",
"break",
";",
"}",
"}",
"}",
"}",
"return",
"table",
";",
"}"
] |
[
"get",
"map",
"boolean"
] |
[
"public",
"map",
"<",
"string",
",",
"boolean",
">",
"get",
"map",
"boolean",
"(",
")",
"{",
"return",
"map",
"boolean",
";",
"}"
] |
[
"fail",
"if",
"any",
"errors",
"have",
"been",
"enqueued",
"implementations",
"may",
"throw",
"exceptions",
"or",
"report",
"the",
"errors",
"through",
"another",
"channel",
"callers",
"are",
"responsible",
"for",
"clearing",
"enqueued",
"errors"
] |
[
"void",
"handle",
"errors",
"(",
"list",
"<",
"string",
">",
"errors",
")",
";"
] |
[
"used",
"to",
"merge",
"multiple",
"incomplete",
"spans",
"representing",
"the",
"same",
"operation",
"on",
"the",
"same",
"host",
"do",
"not",
"use",
"this",
"to",
"merge",
"spans",
"that",
"occur",
"on",
"different",
"hosts"
] |
[
"public",
"builder",
"merge",
"(",
"span",
"source",
")",
"{",
"if",
"(",
"trace",
"id",
"=",
"=",
"null",
")",
"trace",
"id",
"=",
"source",
"trace",
"id",
";",
"if",
"(",
"id",
"=",
"=",
"null",
")",
"id",
"=",
"source",
"id",
";",
"if",
"(",
"parent",
"id",
"=",
"=",
"null",
")",
"parent",
"id",
"=",
"source",
"parent",
"id",
";",
"if",
"(",
"kind",
"=",
"=",
"null",
")",
"kind",
"=",
"source",
"kind",
";",
"if",
"(",
"name",
"=",
"=",
"null",
")",
"name",
"=",
"source",
"name",
";",
"if",
"(",
"timestamp",
"=",
"=",
"0l",
")",
"timestamp",
"=",
"source",
"timestamp",
";",
"if",
"(",
"duration",
"=",
"=",
"0l",
")",
"duration",
"=",
"source",
"duration",
";",
"if",
"(",
"local",
"endpoint",
"=",
"=",
"null",
")",
"{",
"local",
"endpoint",
"=",
"source",
"local",
"endpoint",
";",
"}",
"else",
"if",
"(",
"source",
"local",
"endpoint",
"!",
"=",
"null",
")",
"{",
"local",
"endpoint",
"=",
"local",
"endpoint",
"to",
"builder",
"(",
")",
"merge",
"(",
"source",
"local",
"endpoint",
")",
"build",
"(",
")",
";",
"}",
"if",
"(",
"remote",
"endpoint",
"=",
"=",
"null",
")",
"{",
"remote",
"endpoint",
"=",
"source",
"remote",
"endpoint",
";",
"}",
"else",
"if",
"(",
"source",
"remote",
"endpoint",
"!",
"=",
"null",
")",
"{",
"remote",
"endpoint",
"=",
"remote",
"endpoint",
"to",
"builder",
"(",
")",
"merge",
"(",
"source",
"remote",
"endpoint",
")",
"build",
"(",
")",
";",
"}",
"if",
"(",
"!",
"source",
"annotations",
"is",
"empty",
"(",
")",
")",
"{",
"if",
"(",
"annotations",
"=",
"=",
"null",
")",
"{",
"annotations",
"=",
"new",
"array",
"list",
"<",
"annotation",
">",
"(",
"source",
"annotations",
"size",
"(",
")",
")",
";",
"}",
"annotations",
"add",
"all",
"(",
"source",
"annotations",
")",
";",
"}",
"if",
"(",
"!",
"source",
"tags",
"is",
"empty",
"(",
")",
")",
"{",
"if",
"(",
"tags",
"=",
"=",
"null",
")",
"tags",
"=",
"new",
"tree",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"tags",
"put",
"all",
"(",
"source",
"tags",
")",
";",
"}",
"flags",
"=",
"flags",
"|",
"source",
"flags",
";",
"return",
"this",
";",
"}"
] |
[
"put",
"the",
"block",
"to",
"this",
"ibr"
] |
[
"void",
"put",
"(",
"received",
"deleted",
"block",
"info",
"rdbi",
")",
"{",
"blocks",
"put",
"(",
"rdbi",
"get",
"block",
"(",
")",
",",
"rdbi",
")",
";",
"increase",
"blocks",
"counter",
"(",
"rdbi",
")",
";",
"}"
] |
[
"current",
"application",
"configuration",
",",
"to",
"replace",
"xml",
"config",
":",
"<",
"prev",
">",
"&",
"lt",
";",
"dubbo",
":",
"application",
"name",
"=",
"\"",
"dubbo",
"-",
"demo",
"-",
"application",
"\"",
"&",
"gt",
";",
"<",
"prev",
">"
] |
[
"public",
"application",
"config",
"application",
"config",
"(",
")",
"{",
"application",
"config",
"application",
"config",
"=",
"new",
"application",
"config",
"(",
")",
";",
"application",
"config",
"set",
"name",
"(",
"\"",
"dubbo",
"-",
"demo",
"-",
"application",
"\"",
")",
";",
"return",
"application",
"config",
";",
"}"
] |
[
"returns",
"true",
"if",
"the",
"container",
"initiated",
"the",
"termination",
"of",
"the",
"web",
"application"
] |
[
"public",
"boolean",
"is",
"terminating",
"(",
")",
"{",
"return",
"terminating",
";",
"}"
] |
[
"parses",
"a",
"set",
"of",
"maven",
"repository",
"directory",
"trees",
"looking",
"for",
"and",
"parsing",
"pom",
"files"
] |
[
"static",
"sdk",
"maven",
"repository",
"create",
"(",
"iterable",
"<",
"path",
">",
"maven",
"repositories",
")",
"throws",
"i",
"o",
"exception",
"{",
"collection",
"<",
"path",
">",
"pom",
"paths",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"for",
"(",
"path",
"maven",
"repository",
":",
"maven",
"repositories",
")",
"{",
"pom",
"paths",
"add",
"all",
"(",
"file",
"system",
"utils",
"traverse",
"tree",
"(",
"maven",
"repository",
",",
"path",
"-",
">",
"path",
"to",
"string",
"(",
")",
"ends",
"with",
"(",
"\"",
"pom",
"\"",
")",
")",
")",
";",
"}",
"immutable",
"sorted",
"set",
"builder",
"<",
"pom",
">",
"poms",
"=",
"new",
"immutable",
"sorted",
"set",
"builder",
"<",
">",
"(",
"ordering",
"using",
"to",
"string",
"(",
")",
")",
";",
"for",
"(",
"path",
"pom",
"path",
":",
"pom",
"paths",
")",
"{",
"try",
"{",
"pom",
"pom",
"=",
"pom",
"parse",
"(",
"pom",
"path",
")",
";",
"if",
"(",
"pom",
"!",
"=",
"null",
")",
"{",
"poms",
"add",
"(",
"pom",
")",
";",
"}",
"}",
"catch",
"(",
"parser",
"configuration",
"exception",
"|",
"s",
"a",
"x",
"exception",
"e",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"e",
")",
";",
"}",
"}",
"return",
"new",
"sdk",
"maven",
"repository",
"(",
"poms",
"build",
"(",
")",
")",
";",
"}"
] |
[
"should",
"be",
"called",
"if",
"the",
"thread",
"that",
"uses",
"this",
"cache",
"is",
"about",
"to",
"exist",
"to",
"release",
"resources",
"out",
"of",
"the",
"cache"
] |
[
"void",
"free",
"(",
"boolean",
"finalizer",
")",
"{",
"/",
"/",
"as",
"free",
"(",
")",
"may",
"be",
"called",
"either",
"by",
"the",
"finalizer",
"or",
"by",
"fast",
"thread",
"local",
"on",
"removal",
"(",
")",
"we",
"need",
"to",
"ensure",
"/",
"/",
"we",
"only",
"call",
"this",
"one",
"time",
"if",
"(",
"freed",
"compare",
"and",
"set",
"(",
"false",
",",
"true",
")",
")",
"{",
"int",
"num",
"freed",
"=",
"free",
"(",
"small",
"sub",
"page",
"direct",
"caches",
",",
"finalizer",
")",
"+",
"free",
"(",
"normal",
"direct",
"caches",
",",
"finalizer",
")",
"+",
"free",
"(",
"small",
"sub",
"page",
"heap",
"caches",
",",
"finalizer",
")",
"+",
"free",
"(",
"normal",
"heap",
"caches",
",",
"finalizer",
")",
";",
"if",
"(",
"num",
"freed",
">",
"0",
"&",
"&",
"logger",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"logger",
"debug",
"(",
"\"",
"freed",
"{",
"}",
"thread",
"-",
"local",
"buffer",
"(",
"s",
")",
"from",
"thread",
":",
"{",
"}",
"\"",
",",
"num",
"freed",
",",
"thread",
"current",
"thread",
"(",
")",
"get",
"name",
"(",
")",
")",
";",
"}",
"if",
"(",
"direct",
"arena",
"!",
"=",
"null",
")",
"{",
"direct",
"arena",
"num",
"thread",
"caches",
"get",
"and",
"decrement",
"(",
")",
";",
"}",
"if",
"(",
"heap",
"arena",
"!",
"=",
"null",
")",
"{",
"heap",
"arena",
"num",
"thread",
"caches",
"get",
"and",
"decrement",
"(",
")",
";",
"}",
"}",
"}"
] |
[
"executes",
"a",
"unary",
"call",
"and",
"blocks",
"on",
"the",
"response",
"the",
"{",
"@",
"code",
"call",
"}",
"should",
"not",
"be",
"already",
"started",
"after",
"calling",
"this",
"method",
",",
"{",
"@",
"code",
"call",
"}",
"should",
"no",
"longer",
"be",
"used"
] |
[
"public",
"static",
"<",
"req",
"t",
",",
"resp",
"t",
">",
"resp",
"t",
"blocking",
"unary",
"call",
"(",
"client",
"call",
"<",
"req",
"t",
",",
"resp",
"t",
">",
"call",
",",
"req",
"t",
"req",
")",
"{",
"try",
"{",
"return",
"get",
"unchecked",
"(",
"future",
"unary",
"call",
"(",
"call",
",",
"req",
")",
")",
";",
"}",
"catch",
"(",
"runtime",
"exception",
"e",
")",
"{",
"throw",
"cancel",
"throw",
"(",
"call",
",",
"e",
")",
";",
"}",
"catch",
"(",
"error",
"e",
")",
"{",
"throw",
"cancel",
"throw",
"(",
"call",
",",
"e",
")",
";",
"}",
"}"
] |
[
"sets",
"the",
"basic",
"cost",
"for",
"this",
"node",
"to",
"the",
"given",
"value",
",",
"and",
"sets",
"the",
"cumulative",
"costs",
"to",
"those",
"costs",
"plus",
"the",
"cost",
"shares",
"of",
"all",
"inputs",
"(",
"regular",
"and",
"broadcast",
")"
] |
[
"public",
"void",
"set",
"costs",
"(",
"costs",
"node",
"costs",
")",
"{",
"/",
"/",
"set",
"the",
"node",
"costs",
"this",
"node",
"costs",
"=",
"node",
"costs",
";",
"/",
"/",
"the",
"cumulative",
"costs",
"are",
"the",
"node",
"costs",
"plus",
"the",
"costs",
"of",
"all",
"inputs",
"this",
"cumulative",
"costs",
"=",
"node",
"costs",
"clone",
"(",
")",
";",
"/",
"/",
"add",
"all",
"the",
"normal",
"inputs",
"for",
"(",
"plan",
"node",
"pred",
":",
"get",
"predecessors",
"(",
")",
")",
"{",
"costs",
"parent",
"costs",
"=",
"pred",
"get",
"cumulative",
"costs",
"share",
"(",
")",
";",
"if",
"(",
"parent",
"costs",
"!",
"=",
"null",
")",
"{",
"this",
"cumulative",
"costs",
"add",
"costs",
"(",
"parent",
"costs",
")",
";",
"}",
"else",
"{",
"throw",
"new",
"compiler",
"exception",
"(",
"\"",
"trying",
"to",
"set",
"the",
"costs",
"of",
"an",
"operator",
"before",
"the",
"predecessor",
"costs",
"are",
"computed",
"\"",
")",
";",
"}",
"}",
"/",
"/",
"add",
"all",
"broadcast",
"variable",
"inputs",
"if",
"(",
"this",
"broadcast",
"inputs",
"!",
"=",
"null",
")",
"{",
"for",
"(",
"named",
"channel",
"nc",
":",
"this",
"broadcast",
"inputs",
")",
"{",
"costs",
"bc",
"input",
"cost",
"=",
"nc",
"get",
"source",
"(",
")",
"get",
"cumulative",
"costs",
"share",
"(",
")",
";",
"if",
"(",
"bc",
"input",
"cost",
"!",
"=",
"null",
")",
"{",
"this",
"cumulative",
"costs",
"add",
"costs",
"(",
"bc",
"input",
"cost",
")",
";",
"}",
"else",
"{",
"throw",
"new",
"compiler",
"exception",
"(",
"\"",
"trying",
"to",
"set",
"the",
"costs",
"of",
"an",
"operator",
"before",
"the",
"broadcast",
"input",
"costs",
"are",
"computed",
"\"",
")",
";",
"}",
"}",
"}",
"}"
] |
[
"callback",
"for",
"when",
"the",
"matrix",
"displaying",
"the",
"drawable",
"has",
"changed",
"this",
"could",
"be",
"because",
"the",
"view",
"'",
"s",
"bounds",
"have",
"changed",
",",
"or",
"the",
"user",
"has",
"zoomed"
] |
[
"void",
"on",
"matrix",
"changed",
"(",
"rect",
"f",
"rect",
")",
";"
] |
[
"also",
"has",
"counting",
"before",
"advice"
] |
[
"private",
"void",
"cglib",
"assertions",
"(",
"test",
"bean",
"tb",
")",
"{",
"counting",
"before",
"advice",
"cba",
"=",
"(",
"counting",
"before",
"advice",
")",
"bean",
"factory",
"get",
"bean",
"(",
"\"",
"counting",
"before",
"advice",
"\"",
")",
";",
"nop",
"interceptor",
"nop",
"=",
"(",
"nop",
"interceptor",
")",
"bean",
"factory",
"get",
"bean",
"(",
"\"",
"nop",
"interceptor",
"\"",
")",
";",
"assert",
"that",
"(",
"cba",
"get",
"calls",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"0",
")",
";",
"assert",
"that",
"(",
"nop",
"get",
"count",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"0",
")",
";",
"assert",
"that",
"(",
"aop",
"utils",
"is",
"cglib",
"proxy",
"(",
"tb",
")",
")",
"is",
"true",
"(",
")",
";",
"int",
"age",
"=",
"5",
";",
"tb",
"set",
"age",
"(",
"age",
")",
";",
"assert",
"that",
"(",
"tb",
"get",
"age",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"age",
")",
";",
"assert",
"that",
"(",
"nop",
"get",
"count",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"2",
")",
";",
"assert",
"that",
"(",
"cba",
"get",
"calls",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"2",
")",
";",
"}"
] |
[
"disable",
"a",
"bundle",
"and",
"notify",
"listeners"
] |
[
"public",
"boolean",
"disable",
"(",
"ghidra",
"bundle",
"bundle",
")",
"{",
"if",
"(",
"bundle",
"is",
"enabled",
"(",
")",
")",
"{",
"bundle",
"set",
"enabled",
"(",
"false",
")",
";",
"fire",
"bundle",
"enablement",
"change",
"(",
"bundle",
",",
"false",
")",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}"
] |
[
"get",
"name",
"integer"
] |
[
"public",
"integer",
"get",
"name",
"integer",
"(",
")",
"{",
"return",
"name",
"integer",
";",
"}"
] |
[
"since",
"the",
"container",
"contains",
"both",
"the",
"field",
"extractors",
"and",
"the",
"visible",
"columns",
",",
"compact",
"the",
"information",
"in",
"the",
"listener",
"through",
"a",
"bitset",
"that",
"acts",
"as",
"a",
"mask",
"on",
"what",
"extractors",
"are",
"used",
"for",
"the",
"visible",
"columns"
] |
[
"public",
"bit",
"set",
"column",
"mask",
"(",
"list",
"<",
"attribute",
">",
"columns",
")",
"{",
"bit",
"set",
"mask",
"=",
"new",
"bit",
"set",
"(",
"fields",
"size",
"(",
")",
")",
";",
"alias",
"name",
"(",
"columns",
"get",
"(",
"0",
")",
")",
";",
"for",
"(",
"attribute",
"column",
":",
"columns",
")",
"{",
"expression",
"expression",
"=",
"aliases",
"get",
"or",
"default",
"(",
"column",
",",
"column",
")",
";",
"/",
"/",
"find",
"the",
"column",
"index",
"string",
"id",
"=",
"expressions",
"id",
"(",
"expression",
")",
";",
"int",
"index",
"=",
"-",
"1",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"fields",
"size",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"tuple",
"<",
"field",
"extraction",
",",
"string",
">",
"tuple",
"=",
"fields",
"get",
"(",
"i",
")",
";",
"/",
"/",
"if",
"the",
"index",
"is",
"already",
"set",
"there",
"is",
"a",
"collision",
",",
"/",
"/",
"so",
"continue",
"searching",
"for",
"the",
"other",
"tuple",
"with",
"the",
"same",
"id",
"if",
"(",
"mask",
"get",
"(",
"i",
")",
"=",
"=",
"false",
"&",
"&",
"tuple",
"v",
"2",
"(",
")",
"equals",
"(",
"id",
")",
")",
"{",
"index",
"=",
"i",
";",
"break",
";",
"}",
"}",
"if",
"(",
"index",
">",
"-",
"1",
")",
"{",
"mask",
"set",
"(",
"index",
")",
";",
"}",
"else",
"{",
"throw",
"new",
"sql",
"illegal",
"argument",
"exception",
"(",
"\"",
"cannot",
"resolve",
"field",
"extractor",
"index",
"for",
"column",
"[",
"{",
"}",
"]",
"\"",
",",
"column",
")",
";",
"}",
"}",
"return",
"mask",
";",
"}"
] |
[
"obtain",
"a",
"named",
"parameter",
"from",
"the",
"given",
"request",
"parameters",
"see",
"{",
"@",
"link",
"#",
"find",
"parameter",
"value",
"(",
"java",
"util",
"map",
",",
"string",
")",
"}",
"for",
"a",
"description",
"of",
"the",
"lookup",
"algorithm"
] |
[
"public",
"static",
"string",
"find",
"parameter",
"value",
"(",
"servlet",
"request",
"request",
",",
"string",
"name",
")",
"{",
"return",
"find",
"parameter",
"value",
"(",
"request",
"get",
"parameter",
"map",
"(",
")",
",",
"name",
")",
";",
"}"
] |
[
"asserts",
"that",
"previous",
"window",
"indices",
"for",
"each",
"window",
"depending",
"on",
"the",
"repeat",
"mode",
"and",
"the",
"shuffle",
"mode",
"are",
"equal",
"to",
"the",
"given",
"sequence"
] |
[
"public",
"static",
"void",
"assert",
"previous",
"window",
"indices",
"(",
"timeline",
"timeline",
",",
"@",
"player",
"repeat",
"mode",
"int",
"repeat",
"mode",
",",
"boolean",
"shuffle",
"mode",
"enabled",
",",
"int",
"expected",
"previous",
"window",
"indices",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"timeline",
"get",
"window",
"count",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"assert",
"that",
"(",
"timeline",
"get",
"previous",
"window",
"index",
"(",
"i",
",",
"repeat",
"mode",
",",
"shuffle",
"mode",
"enabled",
")",
")",
"is",
"equal",
"to",
"(",
"expected",
"previous",
"window",
"indices",
"[",
"i",
"]",
")",
";",
"}",
"}"
] |
[
"whether",
"the",
"message",
"broker",
"is",
"currently",
"available",
"and",
"able",
"to",
"process",
"messages",
"note",
"that",
"this",
"is",
"in",
"addition",
"to",
"the",
"{",
"@",
"link",
"#",
"is",
"running",
"(",
")",
"}",
"flag",
",",
"which",
"indicates",
"whether",
"this",
"message",
"handler",
"is",
"running",
"in",
"other",
"words",
"the",
"message",
"handler",
"must",
"first",
"be",
"running",
"and",
"then",
"the",
"{",
"@",
"code",
"#",
"is",
"broker",
"available",
"(",
")",
"}",
"flag",
"may",
"still",
"independently",
"alternate",
"between",
"being",
"on",
"and",
"off",
"depending",
"on",
"the",
"concrete",
"sub",
"-",
"class",
"implementation",
"application",
"components",
"may",
"implement",
"{",
"@",
"code",
"org",
"springframework",
"context",
"application",
"listener",
"&",
"lt",
";",
"broker",
"availability",
"event",
"&",
"gt",
";",
"}",
"to",
"receive",
"notifications",
"when",
"broker",
"becomes",
"available",
"and",
"unavailable"
] |
[
"public",
"boolean",
"is",
"broker",
"available",
"(",
")",
"{",
"return",
"this",
"broker",
"available",
"get",
"(",
")",
";",
"}"
] |
[
"test",
"serialization",
"of",
"outer",
"boolean",
"types",
"<",
"b",
">",
"200",
"<",
"b",
">",
"-",
"output",
"boolean"
] |
[
"public",
"boolean",
"fake",
"outer",
"boolean",
"serialize",
"(",
"boolean",
"body",
")",
"throws",
"rest",
"client",
"exception",
"{",
"return",
"fake",
"outer",
"boolean",
"serialize",
"with",
"http",
"info",
"(",
"body",
")",
"get",
"body",
"(",
")",
";",
"}"
] |
[
"request",
"must",
"be",
"authenticated"
] |
[
"default",
"boolean",
"request",
"must",
"be",
"authenticated",
"(",
")",
"{",
"return",
"false",
";",
"}"
] |
[
"return",
"if",
"the",
"given",
"method",
"name",
"matches",
"the",
"mapped",
"name",
"the",
"default",
"implementation",
"checks",
"for",
"\"",
"xxx",
"\"",
",",
"\"",
"xxx",
"\"",
"and",
"\"",
"xxx",
"\"",
"matches",
",",
"as",
"well",
"as",
"direct",
"equality"
] |
[
"protected",
"boolean",
"is",
"match",
"(",
"string",
"method",
"name",
",",
"string",
"mapped",
"name",
")",
"{",
"return",
"pattern",
"match",
"utils",
"simple",
"match",
"(",
"mapped",
"name",
",",
"method",
"name",
")",
";",
"}"
] |
[
"returns",
"a",
"funnel",
"for",
"longs"
] |
[
"public",
"static",
"funnel",
"<",
"long",
">",
"long",
"funnel",
"(",
")",
"{",
"return",
"long",
"funnel",
"instance",
";",
"}"
] |
[
"returns",
"an",
"{",
"@",
"link",
"endpoint",
"pair",
"}",
"representing",
"the",
"endpoints",
"of",
"an",
"edge",
"in",
"{",
"@",
"code",
"graph",
"}"
] |
[
"static",
"<",
"n",
">",
"endpoint",
"pair",
"<",
"n",
">",
"of",
"(",
"graph",
"<",
"?",
">",
"graph",
",",
"n",
"node",
"u",
",",
"n",
"node",
"v",
")",
"{",
"return",
"graph",
"is",
"directed",
"(",
")",
"?",
"ordered",
"(",
"node",
"u",
",",
"node",
"v",
")",
":",
"unordered",
"(",
"node",
"u",
",",
"node",
"v",
")",
";",
"}"
] |
[
"computes",
"the",
"per",
"-",
"class",
"accuracy",
"results",
"based",
"on",
"multiclass",
"confusion",
"matrix",
"'",
"s",
"result",
"time",
"complexity",
"of",
"this",
"method",
"is",
"linear",
"wrt",
"multiclass",
"confusion",
"matrix",
"size",
",",
"so",
"o",
"(",
"n",
"^",
"2",
")",
"where",
"n",
"is",
"the",
"matrix",
"dimension",
"this",
"method",
"is",
"visible",
"for",
"testing",
"only"
] |
[
"static",
"list",
"<",
"per",
"class",
"single",
"value",
">",
"compute",
"per",
"class",
"accuracy",
"(",
"multiclass",
"confusion",
"matrix",
"result",
"matrix",
"result",
")",
"{",
"assert",
"matrix",
"result",
"get",
"other",
"actual",
"class",
"count",
"(",
")",
"=",
"=",
"0",
";",
"/",
"/",
"number",
"of",
"actual",
"classes",
"taken",
"into",
"account",
"int",
"n",
"=",
"matrix",
"result",
"get",
"confusion",
"matrix",
"(",
")",
"size",
"(",
")",
";",
"/",
"/",
"total",
"number",
"of",
"documents",
"taken",
"into",
"account",
"long",
"total",
"doc",
"count",
"=",
"matrix",
"result",
"get",
"confusion",
"matrix",
"(",
")",
"stream",
"(",
")",
"map",
"to",
"long",
"(",
"multiclass",
"confusion",
"matrix",
"actual",
"class",
":",
":",
"get",
"actual",
"class",
"doc",
"count",
")",
"sum",
"(",
")",
";",
"list",
"<",
"per",
"class",
"single",
"value",
">",
"classes",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"n",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"n",
";",
"+",
"+",
"i",
")",
"{",
"string",
"class",
"name",
"=",
"matrix",
"result",
"get",
"confusion",
"matrix",
"(",
")",
"get",
"(",
"i",
")",
"get",
"actual",
"class",
"(",
")",
";",
"/",
"/",
"start",
"with",
"the",
"assumption",
"that",
"all",
"the",
"docs",
"were",
"predicted",
"correctly",
"long",
"correct",
"doc",
"count",
"=",
"total",
"doc",
"count",
";",
"for",
"(",
"int",
"j",
"=",
"0",
";",
"j",
"<",
"n",
";",
"+",
"+",
"j",
")",
"{",
"if",
"(",
"i",
"!",
"=",
"j",
")",
"{",
"/",
"/",
"subtract",
"errors",
"(",
"false",
"negatives",
")",
"correct",
"doc",
"count",
"-",
"=",
"matrix",
"result",
"get",
"confusion",
"matrix",
"(",
")",
"get",
"(",
"i",
")",
"get",
"predicted",
"classes",
"(",
")",
"get",
"(",
"j",
")",
"get",
"count",
"(",
")",
";",
"/",
"/",
"subtract",
"errors",
"(",
"false",
"positives",
")",
"correct",
"doc",
"count",
"-",
"=",
"matrix",
"result",
"get",
"confusion",
"matrix",
"(",
")",
"get",
"(",
"j",
")",
"get",
"predicted",
"classes",
"(",
")",
"get",
"(",
"i",
")",
"get",
"count",
"(",
")",
";",
"}",
"}",
"/",
"/",
"subtract",
"errors",
"(",
"false",
"negatives",
")",
"for",
"classes",
"other",
"than",
"explicitly",
"listed",
"in",
"confusion",
"matrix",
"correct",
"doc",
"count",
"-",
"=",
"matrix",
"result",
"get",
"confusion",
"matrix",
"(",
")",
"get",
"(",
"i",
")",
"get",
"other",
"predicted",
"class",
"doc",
"count",
"(",
")",
";",
"classes",
"add",
"(",
"new",
"per",
"class",
"single",
"value",
"(",
"class",
"name",
",",
"(",
"(",
"double",
")",
"correct",
"doc",
"count",
")",
"/",
"total",
"doc",
"count",
")",
")",
";",
"}",
"return",
"classes",
";",
"}"
] |
[
"for",
"requests",
"to",
"a",
"valid",
"rest",
"endpoint",
"using",
"an",
"unsupported",
"http",
"method",
",",
"verify",
"that",
"a",
"405",
"http",
"response",
"code",
"is",
"returned",
",",
"and",
"that",
"the",
"response",
"'",
"allow",
"'",
"header",
"includes",
"a",
"list",
"of",
"valid",
"http",
"methods",
"for",
"the",
"endpoint",
"(",
"see",
"<",
"a",
"href",
"=",
"\"",
"https",
":",
"tools",
"ietf",
"orghtmlrfc",
"2",
"6",
"1",
"6",
"#",
"section",
"-",
"10",
"4",
"6",
"\"",
">",
"http1",
"1",
"-",
"10",
"4",
"6",
"-",
"405",
"method",
"not",
"allowed",
")"
] |
[
"public",
"void",
"test",
"unsupported",
"method",
"response",
"http",
"header",
"(",
")",
"throws",
"exception",
"{",
"/",
"*",
"*",
"generate",
"a",
"random",
"set",
"of",
"candidate",
"valid",
"http",
"methods",
"to",
"register",
"*",
"with",
"the",
"test",
"rest",
"controller",
"endpoint",
"enums",
"are",
"returned",
"in",
"the",
"*",
"order",
"they",
"are",
"declared",
",",
"so",
"the",
"first",
"step",
"is",
"to",
"shuffle",
"the",
"http",
"*",
"method",
"list",
",",
"passing",
"in",
"the",
"randomized",
"context",
"'",
"s",
"random",
"instance",
",",
"*",
"before",
"picking",
"out",
"a",
"candidate",
"sublist",
"*",
"/",
"list",
"<",
"rest",
"request",
"method",
">",
"valid",
"http",
"method",
"array",
"=",
"new",
"array",
"list",
"<",
"rest",
"request",
"method",
">",
"(",
"arrays",
"as",
"list",
"(",
"rest",
"request",
"method",
"values",
"(",
")",
")",
")",
";",
"valid",
"http",
"method",
"array",
"remove",
"(",
"rest",
"request",
"method",
"options",
")",
";",
"collections",
"shuffle",
"(",
"valid",
"http",
"method",
"array",
",",
"random",
"(",
")",
")",
";",
"/",
"*",
"*",
"the",
"upper",
"bound",
"of",
"the",
"potential",
"sublist",
"is",
"one",
"less",
"than",
"the",
"size",
"of",
"*",
"the",
"array",
",",
"so",
"we",
"are",
"guaranteed",
"at",
"least",
"one",
"invalid",
"method",
"to",
"test",
"*",
"/",
"valid",
"http",
"method",
"array",
"=",
"valid",
"http",
"method",
"array",
"sub",
"list",
"(",
"0",
",",
"random",
"int",
"between",
"(",
"1",
",",
"valid",
"http",
"method",
"array",
"size",
"(",
")",
"-",
"1",
")",
")",
";",
"assert",
"(",
"valid",
"http",
"method",
"array",
"size",
"(",
")",
">",
"0",
")",
";",
"assert",
"(",
"valid",
"http",
"method",
"array",
"size",
"(",
")",
"<",
"rest",
"request",
"method",
"values",
"(",
")",
"length",
")",
";",
"/",
"*",
"*",
"generate",
"an",
"inverse",
"list",
"of",
"one",
"or",
"more",
"candidate",
"invalid",
"http",
"*",
"methods",
",",
"so",
"we",
"have",
"a",
"candidate",
"method",
"to",
"fire",
"at",
"the",
"test",
"endpoint",
"*",
"/",
"list",
"<",
"rest",
"request",
"method",
">",
"invalid",
"http",
"method",
"array",
"=",
"new",
"array",
"list",
"<",
"rest",
"request",
"method",
">",
"(",
"arrays",
"as",
"list",
"(",
"rest",
"request",
"method",
"values",
"(",
")",
")",
")",
";",
"invalid",
"http",
"method",
"array",
"remove",
"all",
"(",
"valid",
"http",
"method",
"array",
")",
";",
"/",
"/",
"remove",
"options",
",",
"or",
"else",
"we",
"'",
"ll",
"get",
"a",
"200",
"instead",
"of",
"405",
"invalid",
"http",
"method",
"array",
"remove",
"(",
"rest",
"request",
"method",
"options",
")",
";",
"assert",
"(",
"invalid",
"http",
"method",
"array",
"size",
"(",
")",
">",
"0",
")",
";",
"/",
"/",
"initialize",
"test",
"candidate",
"rest",
"controller",
"circuit",
"breaker",
"service",
"circuit",
"breaker",
"service",
"=",
"new",
"hierarchy",
"circuit",
"breaker",
"service",
"(",
"settings",
"empty",
",",
"collections",
"empty",
"list",
"(",
")",
",",
"new",
"cluster",
"settings",
"(",
"settings",
"empty",
",",
"cluster",
"settings",
"built",
"in",
"cluster",
"settings",
")",
")",
";",
"final",
"settings",
"settings",
"=",
"settings",
"empty",
";",
"usage",
"service",
"usage",
"service",
"=",
"new",
"usage",
"service",
"(",
")",
";",
"rest",
"controller",
"rest",
"controller",
"=",
"new",
"rest",
"controller",
"(",
"collections",
"empty",
"set",
"(",
")",
",",
"null",
",",
"null",
",",
"circuit",
"breaker",
"service",
",",
"usage",
"service",
",",
"compatible",
"version",
"current",
"version",
")",
";",
"/",
"/",
"a",
"basic",
"rest",
"handler",
"handles",
"requests",
"to",
"the",
"endpoint",
"rest",
"handler",
"rest",
"handler",
"=",
"new",
"rest",
"handler",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"handle",
"request",
"(",
"rest",
"request",
"request",
",",
"rest",
"channel",
"channel",
",",
"node",
"client",
"client",
")",
"throws",
"exception",
"{",
"channel",
"send",
"response",
"(",
"new",
"test",
"response",
"(",
")",
")",
";",
"}",
"}",
";",
"/",
"/",
"register",
"valid",
"test",
"handlers",
"with",
"test",
"rest",
"controller",
"for",
"(",
"rest",
"request",
"method",
"method",
":",
"valid",
"http",
"method",
"array",
")",
"{",
"rest",
"controller",
"register",
"handler",
"(",
"method",
",",
"\"",
"/",
"\"",
",",
"rest",
"handler",
")",
";",
"}",
"/",
"/",
"generate",
"a",
"test",
"request",
"with",
"an",
"invalid",
"http",
"method",
"fake",
"rest",
"request",
"builder",
"fake",
"rest",
"request",
"builder",
"=",
"new",
"fake",
"rest",
"request",
"builder",
"(",
"x",
"content",
"registry",
"(",
")",
")",
";",
"fake",
"rest",
"request",
"builder",
"with",
"method",
"(",
"invalid",
"http",
"method",
"array",
"get",
"(",
"0",
")",
")",
";",
"rest",
"request",
"rest",
"request",
"=",
"fake",
"rest",
"request",
"builder",
"build",
"(",
")",
";",
"/",
"/",
"send",
"the",
"request",
"and",
"verify",
"the",
"response",
"status",
"code",
"fake",
"rest",
"channel",
"rest",
"channel",
"=",
"new",
"fake",
"rest",
"channel",
"(",
"rest",
"request",
",",
"false",
",",
"1",
")",
";",
"rest",
"controller",
"dispatch",
"request",
"(",
"rest",
"request",
",",
"rest",
"channel",
",",
"new",
"thread",
"context",
"(",
"settings",
"empty",
")",
")",
";",
"assert",
"that",
"(",
"rest",
"channel",
"captured",
"response",
"(",
")",
"status",
"(",
")",
"get",
"status",
"(",
")",
",",
"is",
"(",
"405",
")",
")",
";",
"/",
"*",
"*",
"verify",
"the",
"response",
"allow",
"header",
"contains",
"the",
"valid",
"methods",
"for",
"the",
"*",
"test",
"endpoint",
"*",
"/",
"assert",
"that",
"(",
"rest",
"channel",
"captured",
"response",
"(",
")",
"get",
"headers",
"(",
")",
"get",
"(",
"\"",
"allow",
"\"",
")",
",",
"not",
"null",
"value",
"(",
")",
")",
";",
"string",
"response",
"allow",
"header",
"=",
"rest",
"channel",
"captured",
"response",
"(",
")",
"get",
"headers",
"(",
")",
"get",
"(",
"\"",
"allow",
"\"",
")",
"get",
"(",
"0",
")",
";",
"list",
"<",
"string",
">",
"response",
"allow",
"header",
"array",
"=",
"arrays",
"as",
"list",
"(",
"response",
"allow",
"header",
"split",
"(",
"\"",
",",
"\"",
")",
")",
";",
"assert",
"that",
"(",
"response",
"allow",
"header",
"array",
"size",
"(",
")",
",",
"is",
"(",
"valid",
"http",
"method",
"array",
"size",
"(",
")",
")",
")",
";",
"assert",
"that",
"(",
"response",
"allow",
"header",
"array",
",",
"contains",
"in",
"any",
"order",
"(",
"get",
"method",
"name",
"string",
"array",
"(",
"valid",
"http",
"method",
"array",
")",
"to",
"array",
"(",
")",
")",
")",
";",
"}"
] |
[
"returns",
"the",
"active",
"{",
"@",
"link",
"application",
"context",
"}",
"be",
"default",
"this",
"method",
"obtains",
"the",
"context",
"via",
"{",
"@",
"link",
"context",
"loader",
"#",
"get",
"current",
"web",
"application",
"context",
"(",
")",
"}",
",",
"which",
"finds",
"the",
"application",
"context",
"loaded",
"via",
"{",
"@",
"link",
"context",
"loader",
"}",
"typically",
"in",
"a",
"servlet",
"container",
"environment",
"when",
"not",
"running",
"in",
"a",
"servlet",
"container",
"and",
"not",
"using",
"{",
"@",
"link",
"context",
"loader",
"}",
",",
"this",
"method",
"should",
"be",
"overridden"
] |
[
"protected",
"application",
"context",
"get",
"application",
"context",
"(",
")",
"{",
"return",
"context",
"loader",
"get",
"current",
"web",
"application",
"context",
"(",
")",
";",
"}"
] |
[
"test",
"inline",
"additional",
"properties"
] |
[
"public",
"void",
"test",
"inline",
"additional",
"properties",
"(",
"map",
"<",
"string",
",",
"string",
">",
"param",
")",
"throws",
"api",
"exception",
"{",
"object",
"local",
"var",
"post",
"body",
"=",
"param",
";",
"/",
"/",
"verify",
"the",
"required",
"parameter",
"'",
"param",
"'",
"is",
"set",
"if",
"(",
"param",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"api",
"exception",
"(",
"400",
",",
"\"",
"missing",
"the",
"required",
"parameter",
"'",
"param",
"'",
"when",
"calling",
"test",
"inline",
"additional",
"properties",
"\"",
")",
";",
"}",
"/",
"/",
"create",
"path",
"and",
"map",
"variables",
"string",
"local",
"var",
"path",
"=",
"\"",
"/",
"fake",
"/",
"inline",
"-",
"additional",
"properties",
"\"",
";",
"/",
"/",
"query",
"params",
"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",
"=",
"{",
"}",
";",
"final",
"string",
"local",
"var",
"accept",
"=",
"api",
"client",
"select",
"header",
"accept",
"(",
"local",
"var",
"accepts",
")",
";",
"final",
"string",
"[",
"]",
"local",
"var",
"content",
"types",
"=",
"{",
"\"",
"application",
"/",
"json",
"\"",
"}",
";",
"final",
"string",
"local",
"var",
"content",
"type",
"=",
"api",
"client",
"select",
"header",
"content",
"type",
"(",
"local",
"var",
"content",
"types",
")",
";",
"string",
"[",
"]",
"local",
"var",
"auth",
"names",
"=",
"new",
"string",
"[",
"]",
"{",
"}",
";",
"api",
"client",
"invoke",
"a",
"p",
"i",
"(",
"local",
"var",
"path",
",",
"\"",
"post",
"\"",
",",
"local",
"var",
"query",
"params",
",",
"local",
"var",
"collection",
"query",
"params",
",",
"local",
"var",
"post",
"body",
",",
"local",
"var",
"header",
"params",
",",
"local",
"var",
"cookie",
"params",
",",
"local",
"var",
"form",
"params",
",",
"local",
"var",
"accept",
",",
"local",
"var",
"content",
"type",
",",
"local",
"var",
"auth",
"names",
",",
"null",
")",
";",
"}"
] |
[
"create",
"a",
"default",
"aggregate",
"metric",
"double",
"field",
"type",
"containing",
"sum",
"and",
"a",
"value",
"count",
"metrics"
] |
[
"private",
"aggregate",
"double",
"metric",
"field",
"type",
"create",
"default",
"field",
"type",
"(",
"string",
"field",
"name",
")",
"{",
"aggregate",
"double",
"metric",
"field",
"type",
"field",
"type",
"=",
"new",
"aggregate",
"double",
"metric",
"field",
"type",
"(",
"field",
"name",
")",
";",
"for",
"(",
"metric",
"m",
":",
"list",
"of",
"(",
"metric",
"value",
"count",
",",
"metric",
"sum",
")",
")",
"{",
"string",
"subfield",
"name",
"=",
"subfield",
"name",
"(",
"field",
"name",
",",
"m",
")",
";",
"number",
"field",
"mapper",
"number",
"field",
"type",
"subfield",
"=",
"new",
"number",
"field",
"mapper",
"number",
"field",
"type",
"(",
"subfield",
"name",
",",
"number",
"field",
"mapper",
"number",
"type",
"double",
")",
";",
"field",
"type",
"add",
"metric",
"field",
"(",
"m",
",",
"subfield",
")",
";",
"}",
"field",
"type",
"set",
"default",
"metric",
"(",
"metric",
"sum",
")",
";",
"return",
"field",
"type",
";",
"}"
] |
[
"a",
"builder",
"used",
"to",
"set",
"parameters",
"to",
"the",
"output",
"format",
"'",
"s",
"configuration",
"in",
"a",
"fluent",
"way"
] |
[
"public",
"static",
"builder",
"builder",
"(",
")",
"{",
"return",
"new",
"builder",
"(",
")",
";",
"}"
] |
[
"asserts",
"that",
"{",
"@",
"code",
"transformation",
"}",
"is",
"horizontal",
"with",
"the",
"given",
"value",
"of",
"{",
"@",
"code",
"y",
"}",
"includes",
"assertions",
"about",
"all",
"the",
"public",
"instance",
"methods",
"of",
"{",
"@",
"link",
"linear",
"transformation",
"}",
",",
"including",
"an",
"assertion",
"that",
"{",
"@",
"link",
"linear",
"transformation",
"#",
"transform",
"}",
"and",
"{",
"@",
"link",
"linear",
"transformation",
"#",
"slope",
"}",
"on",
"its",
"inverse",
"throws",
"as",
"expected"
] |
[
"static",
"void",
"assert",
"horizontal",
"linear",
"transformation",
"(",
"linear",
"transformation",
"transformation",
",",
"double",
"y",
")",
"{",
"assert",
"that",
"(",
"transformation",
"is",
"horizontal",
"(",
")",
")",
"is",
"true",
"(",
")",
";",
"assert",
"that",
"(",
"transformation",
"is",
"vertical",
"(",
")",
")",
"is",
"false",
"(",
")",
";",
"assert",
"that",
"(",
"transformation",
"inverse",
"(",
")",
"is",
"horizontal",
"(",
")",
")",
"is",
"false",
"(",
")",
";",
"assert",
"that",
"(",
"transformation",
"inverse",
"(",
")",
"is",
"vertical",
"(",
")",
")",
"is",
"true",
"(",
")",
";",
"assert",
"that",
"(",
"transformation",
"transform",
"(",
"-",
"1",
"0",
")",
")",
"is",
"within",
"(",
"allowed",
"error",
")",
"of",
"(",
"y",
")",
";",
"assert",
"that",
"(",
"transformation",
"transform",
"(",
"1",
"0",
")",
")",
"is",
"within",
"(",
"allowed",
"error",
")",
"of",
"(",
"y",
")",
";",
"try",
"{",
"transformation",
"inverse",
"(",
")",
"transform",
"(",
"0",
"0",
")",
";",
"fail",
"(",
"\"",
"expected",
"illegal",
"state",
"exception",
"\"",
")",
";",
"}",
"catch",
"(",
"illegal",
"state",
"exception",
"expected",
")",
"{",
"}",
"assert",
"that",
"(",
"transformation",
"slope",
"(",
")",
")",
"is",
"within",
"(",
"allowed",
"error",
")",
"of",
"(",
"0",
"0",
")",
";",
"try",
"{",
"transformation",
"inverse",
"(",
")",
"slope",
"(",
")",
";",
"fail",
"(",
"\"",
"expected",
"illegal",
"state",
"exception",
"\"",
")",
";",
"}",
"catch",
"(",
"illegal",
"state",
"exception",
"expected",
")",
"{",
"}",
"assert",
"that",
"(",
"transformation",
"inverse",
"(",
")",
")",
"is",
"same",
"instance",
"as",
"(",
"transformation",
"inverse",
"(",
")",
")",
";",
"assert",
"that",
"(",
"transformation",
"inverse",
"(",
")",
"inverse",
"(",
")",
")",
"is",
"same",
"instance",
"as",
"(",
"transformation",
")",
";",
"}"
] |
[
"value",
"of",
"my",
"s",
"q",
"l",
"status",
"flag"
] |
[
"public",
"static",
"my",
"s",
"q",
"l",
"status",
"flag",
"value",
"of",
"(",
"final",
"int",
"value",
")",
"{",
"for",
"(",
"my",
"s",
"q",
"l",
"status",
"flag",
"each",
":",
"values",
"(",
")",
")",
"{",
"if",
"(",
"each",
"value",
"=",
"=",
"value",
")",
"{",
"return",
"each",
";",
"}",
"}",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"string",
"format",
"(",
"\"",
"illegal",
"my",
"s",
"q",
"l",
"status",
"flag",
"value",
"%",
"d",
"\"",
",",
"value",
")",
")",
";",
"}"
] |
[
"get",
"the",
"overview",
"providers",
"in",
"this",
"listing",
"panel"
] |
[
"public",
"list",
"<",
"overview",
"provider",
">",
"get",
"overview",
"providers",
"(",
")",
"{",
"return",
"overview",
"providers",
";",
"}"
] |
[
"used",
"to",
"convert",
"an",
"old",
"style",
"tool",
"xml",
"file",
"by",
"adding",
"in",
"classes",
"in",
"the",
"same",
"packages",
"as",
"those",
"that",
"were",
"names",
"specifically",
"in",
"the",
"xml",
"file"
] |
[
"public",
"list",
"<",
"string",
">",
"fill",
"in",
"package",
"classes",
"(",
"list",
"<",
"string",
">",
"class",
"names",
")",
"{",
"set",
"<",
"plugin",
"package",
">",
"packages",
"=",
"new",
"hash",
"set",
"<",
">",
"(",
")",
";",
"set",
"<",
"string",
">",
"adjusted",
"class",
"names",
"=",
"new",
"hash",
"set",
"<",
">",
"(",
")",
";",
"for",
"(",
"string",
"class",
"name",
":",
"class",
"names",
")",
"{",
"plugin",
"description",
"plugin",
"description",
"=",
"plugin",
"class",
"map",
"get",
"(",
"class",
"name",
")",
";",
"if",
"(",
"plugin",
"description",
"!",
"=",
"null",
")",
"{",
"if",
"(",
"plugin",
"description",
"get",
"status",
"(",
")",
"=",
"=",
"plugin",
"status",
"released",
")",
"{",
"packages",
"add",
"(",
"plugin",
"description",
"get",
"plugin",
"package",
"(",
")",
")",
";",
"}",
"else",
"{",
"adjusted",
"class",
"names",
"add",
"(",
"class",
"name",
")",
";",
"}",
"}",
"}",
"for",
"(",
"plugin",
"package",
"plugin",
"package",
":",
"packages",
")",
"{",
"list",
"<",
"plugin",
"description",
">",
"list",
"=",
"package",
"map",
"get",
"(",
"plugin",
"package",
")",
";",
"for",
"(",
"plugin",
"description",
"plugin",
"description",
":",
"list",
")",
"{",
"if",
"(",
"plugin",
"description",
"get",
"status",
"(",
")",
"!",
"=",
"plugin",
"status",
"released",
")",
"{",
"continue",
";",
"}",
"string",
"name",
"=",
"plugin",
"description",
"get",
"plugin",
"class",
"(",
")",
"get",
"name",
"(",
")",
";",
"adjusted",
"class",
"names",
"add",
"(",
"name",
")",
";",
"}",
"}",
"return",
"new",
"array",
"list",
"<",
">",
"(",
"adjusted",
"class",
"names",
")",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}",
"the",
"default",
"implementation",
"does",
"nothing"
] |
[
"@",
"override",
"public",
"void",
"enter",
"join",
"term",
"(",
"eql",
"base",
"parser",
"join",
"term",
"context",
"ctx",
")",
"{",
"}"
] |
[
"check",
"whether",
"a",
"temporary",
"catalog",
"function",
"is",
"already",
"registered"
] |
[
"public",
"boolean",
"has",
"temporary",
"catalog",
"function",
"(",
"object",
"identifier",
"function",
"identifier",
")",
"{",
"object",
"identifier",
"normalized",
"identifier",
"=",
"function",
"identifier",
"normalize",
"object",
"identifier",
"(",
"function",
"identifier",
")",
";",
"return",
"temp",
"catalog",
"functions",
"contains",
"key",
"(",
"normalized",
"identifier",
")",
";",
"}"
] |
[
"get",
"pet",
"id"
] |
[
"public",
"long",
"get",
"pet",
"id",
"(",
")",
"{",
"return",
"pet",
"id",
";",
"}"
] |
[
"closes",
"the",
"underlying",
"random",
"-",
"access",
"file"
] |
[
"public",
"void",
"close",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"random",
"access",
"file",
"close",
"(",
")",
";",
"}"
] |
[
"compare",
"the",
"given",
"path",
"against",
"configured",
"resource",
"handler",
"mappings",
"and",
"if",
"a",
"match",
"is",
"found",
"use",
"the",
"{",
"@",
"code",
"resource",
"resolver",
"}",
"chain",
"of",
"the",
"matched",
"{",
"@",
"code",
"resource",
"http",
"request",
"handler",
"}",
"to",
"resolve",
"the",
"url",
"path",
"to",
"expose",
"for",
"public",
"use",
"it",
"is",
"expected",
"that",
"the",
"given",
"path",
"is",
"what",
"spring",
"mvc",
"would",
"use",
"for",
"request",
"mapping",
"purposes",
",",
"i",
"e",
"excluding",
"context",
"and",
"servlet",
"path",
"portions",
"if",
"several",
"handler",
"mappings",
"match",
",",
"the",
"handler",
"used",
"will",
"be",
"the",
"one",
"configured",
"with",
"the",
"most",
"specific",
"pattern"
] |
[
"public",
"final",
"string",
"get",
"for",
"lookup",
"path",
"(",
"string",
"lookup",
"path",
")",
"{",
"/",
"/",
"clean",
"duplicate",
"slashes",
"or",
"path",
"within",
"pattern",
"won",
"'",
"t",
"match",
"lookup",
"path",
"string",
"previous",
";",
"do",
"{",
"previous",
"=",
"lookup",
"path",
";",
"lookup",
"path",
"=",
"string",
"utils",
"replace",
"(",
"lookup",
"path",
",",
"\"",
"/",
"/",
"\"",
",",
"\"",
"/",
"\"",
")",
";",
"}",
"while",
"(",
"!",
"lookup",
"path",
"equals",
"(",
"previous",
")",
")",
";",
"list",
"<",
"string",
">",
"matching",
"patterns",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"for",
"(",
"string",
"pattern",
":",
"this",
"handler",
"map",
"key",
"set",
"(",
")",
")",
"{",
"if",
"(",
"get",
"path",
"matcher",
"(",
")",
"match",
"(",
"pattern",
",",
"lookup",
"path",
")",
")",
"{",
"matching",
"patterns",
"add",
"(",
"pattern",
")",
";",
"}",
"}",
"if",
"(",
"!",
"matching",
"patterns",
"is",
"empty",
"(",
")",
")",
"{",
"comparator",
"<",
"string",
">",
"pattern",
"comparator",
"=",
"get",
"path",
"matcher",
"(",
")",
"get",
"pattern",
"comparator",
"(",
"lookup",
"path",
")",
";",
"matching",
"patterns",
"sort",
"(",
"pattern",
"comparator",
")",
";",
"for",
"(",
"string",
"pattern",
":",
"matching",
"patterns",
")",
"{",
"string",
"path",
"within",
"mapping",
"=",
"get",
"path",
"matcher",
"(",
")",
"extract",
"path",
"within",
"pattern",
"(",
"pattern",
",",
"lookup",
"path",
")",
";",
"string",
"path",
"mapping",
"=",
"lookup",
"path",
"substring",
"(",
"0",
",",
"lookup",
"path",
"index",
"of",
"(",
"path",
"within",
"mapping",
")",
")",
";",
"resource",
"http",
"request",
"handler",
"handler",
"=",
"this",
"handler",
"map",
"get",
"(",
"pattern",
")",
";",
"resource",
"resolver",
"chain",
"chain",
"=",
"new",
"default",
"resource",
"resolver",
"chain",
"(",
"handler",
"get",
"resource",
"resolvers",
"(",
")",
")",
";",
"string",
"resolved",
"=",
"chain",
"resolve",
"url",
"path",
"(",
"path",
"within",
"mapping",
",",
"handler",
"get",
"locations",
"(",
")",
")",
";",
"if",
"(",
"resolved",
"=",
"=",
"null",
")",
"{",
"continue",
";",
"}",
"return",
"path",
"mapping",
"+",
"resolved",
";",
"}",
"}",
"if",
"(",
"logger",
"is",
"trace",
"enabled",
"(",
")",
")",
"{",
"logger",
"trace",
"(",
"\"",
"no",
"match",
"for",
"\\",
"\"",
"\"",
"+",
"lookup",
"path",
"+",
"\"",
"\\",
"\"",
"\"",
")",
";",
"}",
"return",
"null",
";",
"}"
] |
[
"returns",
"the",
"size",
"of",
"this",
"big",
"array",
"in",
"bytes"
] |
[
"public",
"long",
"size",
"of",
"(",
")",
"{",
"return",
"instance",
"size",
"+",
"size",
"of",
"size",
"of",
"(",
"array",
")",
"+",
"(",
"segments",
"*",
"size",
"of",
"segment",
")",
";",
"}"
] |
[
"wraps",
"{",
"@",
"link",
"serializer",
"#",
"process",
"(",
"java",
"io",
"output",
"stream",
",",
"object",
")",
"}",
"and",
"calls",
"next",
"serializer",
"in",
"chain"
] |
[
"public",
"void",
"process",
"element",
"(",
"output",
"stream",
"output",
"stream",
",",
"object",
"element",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"can",
"process",
"(",
"element",
")",
")",
"{",
"process",
"(",
"output",
"stream",
",",
"element",
")",
";",
"}",
"else",
"{",
"if",
"(",
"next",
"!",
"=",
"null",
")",
"{",
"this",
"next",
"process",
"element",
"(",
"output",
"stream",
",",
"element",
")",
";",
"}",
"}",
"}"
] |
[
"return",
"if",
"the",
"new",
"type",
"is",
"the",
"same",
"and",
"at",
"most",
"narrows",
"the",
"nullability"
] |
[
"private",
"boolean",
"same",
"type",
"or",
"narrows",
"nullability",
"(",
"rel",
"data",
"type",
"old",
"type",
",",
"rel",
"data",
"type",
"new",
"type",
")",
"{",
"return",
"old",
"type",
"equals",
"(",
"new",
"type",
")",
"|",
"|",
"(",
"sql",
"type",
"util",
"equal",
"sans",
"nullability",
"(",
"rex",
"builder",
"type",
"factory",
",",
"old",
"type",
",",
"new",
"type",
")",
"&",
"&",
"old",
"type",
"is",
"nullable",
"(",
")",
")",
";",
"}"
] |
[
"reads",
"blob",
"content",
"from",
"a",
"{",
"@",
"link",
"bytes",
"reference",
"}",
"and",
"writes",
"it",
"to",
"the",
"container",
"in",
"a",
"new",
"blob",
"with",
"the",
"given",
"name"
] |
[
"default",
"void",
"write",
"blob",
"(",
"string",
"blob",
"name",
",",
"bytes",
"reference",
"bytes",
",",
"boolean",
"fail",
"if",
"already",
"exists",
")",
"throws",
"i",
"o",
"exception",
"{",
"write",
"blob",
"(",
"blob",
"name",
",",
"bytes",
"stream",
"input",
"(",
")",
",",
"bytes",
"length",
"(",
")",
",",
"fail",
"if",
"already",
"exists",
")",
";",
"}"
] |
[
"sets",
"the",
"function",
"that",
"will",
"be",
"called",
"when",
"{",
"@",
"link",
"#",
"do",
"execute",
"(",
"action",
"type",
",",
"action",
"request",
",",
"action",
"listener",
")",
"}",
"is",
"called",
"the",
"given",
"function",
"should",
"return",
"either",
"a",
"subclass",
"of",
"{",
"@",
"link",
"action",
"response",
"}",
"or",
"{",
"@",
"code",
"null",
"}"
] |
[
"public",
"<",
"request",
"extends",
"action",
"request",
",",
"response",
"extends",
"action",
"response",
">",
"void",
"set",
"execute",
"verifier",
"(",
"bi",
"function",
"<",
"action",
"type",
"<",
"response",
">",
",",
"request",
",",
"void",
">",
"verifier",
")",
"{",
"execute",
"verifier",
"set",
"(",
"verifier",
")",
";",
"}"
] |
[
"build",
"the",
"ticket",
"properties"
] |
[
"protected",
"map",
"<",
"string",
",",
"serializable",
">",
"build",
"ticket",
"properties",
"(",
"final",
"j",
"e",
"e",
"context",
"web",
"context",
")",
"{",
"val",
"properties",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"serializable",
">",
"(",
")",
";",
"val",
"theme",
"param",
"name",
"=",
"cas",
"properties",
"get",
"theme",
"(",
")",
"get",
"param",
"name",
"(",
")",
";",
"val",
"local",
"param",
"name",
"=",
"cas",
"properties",
"get",
"locale",
"(",
")",
"get",
"param",
"name",
"(",
")",
";",
"properties",
"put",
"(",
"theme",
"param",
"name",
",",
"web",
"context",
"get",
"request",
"parameter",
"(",
"theme",
"param",
"name",
")",
"map",
"(",
"string",
":",
":",
"value",
"of",
")",
"or",
"else",
"(",
"string",
"utils",
"empty",
")",
")",
";",
"properties",
"put",
"(",
"local",
"param",
"name",
",",
"web",
"context",
"get",
"request",
"parameter",
"(",
"local",
"param",
"name",
")",
"map",
"(",
"string",
":",
":",
"value",
"of",
")",
"or",
"else",
"(",
"string",
"utils",
"empty",
")",
")",
";",
"properties",
"put",
"(",
"cas",
"protocol",
"constants",
"parameter",
"method",
",",
"web",
"context",
"get",
"request",
"parameter",
"(",
"cas",
"protocol",
"constants",
"parameter",
"method",
")",
"map",
"(",
"string",
":",
":",
"value",
"of",
")",
"or",
"else",
"(",
"string",
"utils",
"empty",
")",
")",
";",
"logger",
"debug",
"(",
"\"",
"built",
"ticket",
"properties",
"[",
"{",
"}",
"]",
"\"",
",",
"properties",
")",
";",
"return",
"properties",
";",
"}"
] |
[
"get",
"the",
"value",
"of",
"the",
"<",
"code",
">",
"name",
"<",
"code",
">",
"property",
"as",
"a",
"<",
"code",
">",
"long",
"<",
"code",
">",
"if",
"no",
"such",
"property",
"exists",
",",
"the",
"provided",
"default",
"value",
"is",
"returned",
",",
"or",
"if",
"the",
"specified",
"value",
"is",
"not",
"a",
"valid",
"<",
"code",
">",
"long",
"<",
"code",
">",
",",
"then",
"an",
"error",
"is",
"thrown"
] |
[
"public",
"long",
"get",
"long",
"(",
"string",
"name",
",",
"long",
"default",
"value",
")",
"{",
"string",
"value",
"string",
"=",
"get",
"trimmed",
"(",
"name",
")",
";",
"if",
"(",
"value",
"string",
"=",
"=",
"null",
")",
"return",
"default",
"value",
";",
"string",
"hex",
"string",
"=",
"get",
"hex",
"digits",
"(",
"value",
"string",
")",
";",
"if",
"(",
"hex",
"string",
"!",
"=",
"null",
")",
"{",
"return",
"long",
"parse",
"long",
"(",
"hex",
"string",
",",
"16",
")",
";",
"}",
"return",
"long",
"parse",
"long",
"(",
"value",
"string",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"color",
"'"
] |
[
"public",
"void",
"color",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"color",
"}"
] |
[
"creates",
"list",
"of",
"users",
"with",
"given",
"input",
"array"
] |
[
"public",
"void",
"create",
"users",
"with",
"list",
"input",
"test",
"(",
"test",
"context",
"test",
"context",
")",
"{",
"async",
"async",
"=",
"test",
"context",
"async",
"(",
")",
";",
"list",
"<",
"user",
">",
"body",
"=",
"null",
";",
"api",
"create",
"users",
"with",
"list",
"input",
"(",
"body",
",",
"result",
"-",
">",
"{",
"/",
"/",
"todo",
":",
"test",
"validations",
"async",
"complete",
"(",
")",
";",
"}",
")",
";",
"}"
] |
[
"creates",
"an",
"empty",
"{",
"@",
"code",
"object",
"count",
"linked",
"hash",
"map",
"}",
"instance"
] |
[
"public",
"static",
"<",
"k",
">",
"object",
"count",
"linked",
"hash",
"map",
"<",
"k",
">",
"create",
"(",
")",
"{",
"return",
"new",
"object",
"count",
"linked",
"hash",
"map",
"<",
"k",
">",
"(",
")",
";",
"}"
] |
[
"returns",
"if",
"client",
"certificates",
"are",
"required",
"or",
"not"
] |
[
"public",
"boolean",
"is",
"client",
"cert",
"required",
"(",
")",
"{",
"return",
"require",
"client",
"cert",
";",
"}"
] |
[
"sets",
"the",
"offsets",
"for",
"the",
"first",
"item",
"in",
"a",
"section",
"to",
"make",
"room",
"for",
"the",
"header",
"view"
] |
[
"private",
"void",
"set",
"item",
"offsets",
"for",
"header",
"(",
"rect",
"item",
"offsets",
",",
"view",
"header",
",",
"int",
"orientation",
")",
"{",
"rect",
"header",
"margins",
"=",
"m",
"dimension",
"calculator",
"get",
"margins",
"(",
"header",
")",
";",
"if",
"(",
"orientation",
"=",
"=",
"linear",
"layout",
"manager",
"vertical",
")",
"{",
"item",
"offsets",
"top",
"=",
"header",
"get",
"height",
"(",
")",
"+",
"header",
"margins",
"top",
"+",
"header",
"margins",
"bottom",
";",
"}",
"else",
"{",
"item",
"offsets",
"left",
"=",
"header",
"get",
"width",
"(",
")",
"+",
"header",
"margins",
"left",
"+",
"header",
"margins",
"right",
";",
"}",
"}"
] |
[
"get",
"positions",
"selected"
] |
[
"protected",
"list",
"<",
"integer",
">",
"get",
"positions",
"selected",
"(",
")",
"{",
"list",
"<",
"integer",
">",
"list",
"=",
"new",
"array",
"list",
"<",
"integer",
">",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"checked",
"size",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"checked",
"get",
"(",
"i",
")",
")",
"{",
"list",
"add",
"(",
"i",
")",
";",
"}",
"}",
"return",
"list",
";",
"}"
] |
[
"if",
"{",
"@",
"link",
"#",
"is",
"playing",
"ad",
"(",
")",
"}",
"returns",
"{",
"@",
"code",
"true",
"}",
",",
"returns",
"the",
"duration",
"of",
"the",
"current",
"content",
"window",
"in",
"milliseconds",
",",
"or",
"{",
"@",
"link",
"c",
"#",
"time",
"unset",
"}",
"if",
"the",
"duration",
"is",
"not",
"known",
"if",
"there",
"is",
"no",
"ad",
"playing",
",",
"the",
"returned",
"duration",
"is",
"the",
"same",
"as",
"that",
"returned",
"by",
"{",
"@",
"link",
"#",
"get",
"duration",
"(",
")",
"}"
] |
[
"long",
"get",
"content",
"duration",
"(",
")",
";"
] |
[
"get",
"the",
"local",
"tool",
"chest",
"for",
"the",
"user",
"logged",
"in"
] |
[
"public",
"tool",
"chest",
"get",
"local",
"tool",
"chest",
"(",
")",
"{",
"return",
"project",
"manager",
"get",
"user",
"tool",
"chest",
"(",
")",
";",
"}"
] |
[
"alert",
"the",
"consumer",
"to",
"trigger",
"a",
"new",
"rebalance",
"by",
"rejoining",
"the",
"group",
"this",
"is",
"a",
"nonblocking",
"call",
"that",
"forces",
"the",
"consumer",
"to",
"trigger",
"a",
"new",
"rebalance",
"on",
"the",
"next",
"{",
"@",
"link",
"#",
"poll",
"(",
"duration",
")",
"}",
"call",
"note",
"that",
"this",
"api",
"does",
"not",
"itself",
"initiate",
"the",
"rebalance",
",",
"so",
"you",
"must",
"still",
"call",
"{",
"@",
"link",
"#",
"poll",
"(",
"duration",
")",
"}",
"if",
"a",
"rebalance",
"is",
"already",
"in",
"progress",
"this",
"call",
"will",
"be",
"a",
"no",
"-",
"op",
"if",
"you",
"wish",
"to",
"force",
"an",
"additional",
"rebalance",
"you",
"must",
"complete",
"the",
"current",
"one",
"by",
"calling",
"poll",
"before",
"retrying",
"this",
"api",
"you",
"do",
"not",
"need",
"to",
"call",
"this",
"during",
"normal",
"processing",
",",
"as",
"the",
"consumer",
"group",
"will",
"manage",
"itself",
"automatically",
"and",
"rebalance",
"when",
"necessary",
"however",
"there",
"may",
"be",
"situations",
"where",
"the",
"application",
"wishes",
"to",
"trigger",
"a",
"rebalance",
"that",
"would",
"otherwise",
"not",
"occur",
"for",
"example",
",",
"if",
"some",
"condition",
"external",
"and",
"invisible",
"to",
"the",
"consumer",
"and",
"its",
"group",
"changes",
"in",
"a",
"way",
"that",
"would",
"affect",
"the",
"userdata",
"encoded",
"in",
"the",
"{",
"@",
"link",
"org",
"apache",
"kafka",
"clients",
"consumer",
"consumer",
"partition",
"assignor",
"subscription",
"subscription",
"}",
",",
"the",
"consumer",
"will",
"not",
"be",
"notified",
"and",
"no",
"rebalance",
"will",
"occur",
"this",
"api",
"can",
"be",
"used",
"to",
"force",
"the",
"group",
"to",
"rebalance",
"so",
"that",
"the",
"assignor",
"can",
"perform",
"a",
"partition",
"reassignment",
"based",
"on",
"the",
"latest",
"userdata",
"if",
"your",
"assignor",
"does",
"not",
"use",
"this",
"userdata",
",",
"or",
"you",
"do",
"not",
"use",
"a",
"custom",
"{",
"@",
"link",
"org",
"apache",
"kafka",
"clients",
"consumer",
"consumer",
"partition",
"assignor",
"consumer",
"partition",
"assignor",
"}",
",",
"you",
"should",
"not",
"use",
"this",
"api"
] |
[
"public",
"void",
"enforce",
"rebalance",
"(",
")",
"{",
"acquire",
"and",
"ensure",
"open",
"(",
")",
";",
"try",
"{",
"if",
"(",
"coordinator",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"tried",
"to",
"force",
"a",
"rebalance",
"but",
"consumer",
"does",
"not",
"have",
"a",
"group",
"\"",
")",
";",
"}",
"coordinator",
"request",
"rejoin",
"(",
")",
";",
"}",
"finally",
"{",
"release",
"(",
")",
";",
"}",
"}"
] |
[
"sets",
"the",
"execution",
"mode",
"to",
"execute",
"the",
"program",
"the",
"execution",
"mode",
"defines",
"whether",
"data",
"exchanges",
"are",
"performed",
"in",
"a",
"batch",
"or",
"on",
"a",
"pipelined",
"manner",
"the",
"default",
"execution",
"mode",
"is",
"{",
"@",
"link",
"execution",
"mode",
"#",
"pipelined",
"}"
] |
[
"public",
"void",
"set",
"execution",
"mode",
"(",
"execution",
"mode",
"execution",
"mode",
")",
"{",
"this",
"execution",
"mode",
"=",
"execution",
"mode",
";",
"}"
] |
[
"sets",
"a",
"new",
"zoomable",
"transformation",
"and",
"animates",
"to",
"it",
"if",
"desired",
"if",
"this",
"method",
"is",
"called",
"while",
"an",
"animation",
"or",
"gesture",
"is",
"already",
"in",
"progress",
",",
"the",
"current",
"animation",
"or",
"gesture",
"will",
"be",
"stopped",
"first"
] |
[
"public",
"void",
"set",
"transform",
"(",
"matrix",
"new",
"transform",
",",
"long",
"duration",
"ms",
",",
"@",
"nullable",
"runnable",
"on",
"animation",
"complete",
")",
"{",
"f",
"log",
"v",
"(",
"get",
"log",
"tag",
"(",
")",
",",
"\"",
"set",
"transform",
":",
"duration",
"%",
"d",
"ms",
"\"",
",",
"duration",
"ms",
")",
";",
"if",
"(",
"duration",
"ms",
"<",
"=",
"0",
")",
"{",
"set",
"transform",
"immediate",
"(",
"new",
"transform",
")",
";",
"}",
"else",
"{",
"set",
"transform",
"animated",
"(",
"new",
"transform",
",",
"duration",
"ms",
",",
"on",
"animation",
"complete",
")",
";",
"}",
"}"
] |
[
"adjust",
"{",
"@",
"code",
"item",
"}",
"using",
"specific",
"{",
"@",
"code",
"sparse",
"index",
"map",
"}"
] |
[
"protected",
"t",
"adjust",
"item",
"(",
"abstract",
"index",
"map",
"index",
"map",
",",
"t",
"item",
")",
"{",
"return",
"item",
";",
"}"
] |
[
"assert",
"that",
"the",
"given",
"text",
"does",
"not",
"contain",
"the",
"given",
"substring"
] |
[
"public",
"static",
"void",
"does",
"not",
"contain",
"(",
"@",
"nullable",
"string",
"text",
"to",
"search",
",",
"string",
"substring",
")",
"{",
"does",
"not",
"contain",
"(",
"text",
"to",
"search",
",",
"substring",
",",
"(",
")",
"-",
">",
"\"",
"[",
"assertion",
"failed",
"]",
"-",
"this",
"string",
"argument",
"must",
"not",
"contain",
"the",
"substring",
"[",
"\"",
"+",
"substring",
"+",
"\"",
"]",
"\"",
")",
";",
"}"
] |
[
"gets",
"all",
"original",
"settings",
"with",
"the",
"given",
"prefix"
] |
[
"public",
"map",
"<",
"string",
",",
"object",
">",
"originals",
"with",
"prefix",
"(",
"string",
"prefix",
",",
"boolean",
"strip",
")",
"{",
"map",
"<",
"string",
",",
"object",
">",
"result",
"=",
"new",
"recording",
"map",
"<",
">",
"(",
"prefix",
",",
"false",
")",
";",
"for",
"(",
"map",
"entry",
"<",
"string",
",",
"?",
">",
"entry",
":",
"originals",
"entry",
"set",
"(",
")",
")",
"{",
"if",
"(",
"entry",
"get",
"key",
"(",
")",
"starts",
"with",
"(",
"prefix",
")",
"&",
"&",
"entry",
"get",
"key",
"(",
")",
"length",
"(",
")",
">",
"prefix",
"length",
"(",
")",
")",
"{",
"if",
"(",
"strip",
")",
"result",
"put",
"(",
"entry",
"get",
"key",
"(",
")",
"substring",
"(",
"prefix",
"length",
"(",
")",
")",
",",
"entry",
"get",
"value",
"(",
")",
")",
";",
"else",
"result",
"put",
"(",
"entry",
"get",
"key",
"(",
")",
",",
"entry",
"get",
"value",
"(",
")",
")",
";",
"}",
"}",
"return",
"result",
";",
"}"
] |
[
"fake",
"endpoint",
"for",
"testing",
"various",
"parameters",
"가짜",
"엔드",
"포인트",
"fake",
"endpoint",
"for",
"testing",
"various",
"parameters",
"가짜",
"엔드",
"포인트"
] |
[
"public",
"void",
"test",
"endpoint",
"parameters",
"test",
"(",
")",
"throws",
"api",
"exception",
"{",
"big",
"decimal",
"number",
"=",
"null",
";",
"double",
"double",
"=",
"null",
";",
"string",
"pattern",
"without",
"delimiter",
"=",
"null",
";",
"byte",
"[",
"]",
"byte",
"=",
"null",
";",
"integer",
"integer",
"=",
"null",
";",
"integer",
"int",
"3",
"2",
"=",
"null",
";",
"long",
"int",
"6",
"4",
"=",
"null",
";",
"float",
"float",
"=",
"null",
";",
"string",
"string",
"=",
"null",
";",
"file",
"binary",
"=",
"null",
";",
"local",
"date",
"date",
"=",
"null",
";",
"offset",
"date",
"time",
"date",
"time",
"=",
"null",
";",
"string",
"password",
"=",
"null",
";",
"string",
"param",
"callback",
"=",
"null",
";",
"api",
"test",
"endpoint",
"parameters",
"(",
"number",
",",
"double",
",",
"pattern",
"without",
"delimiter",
",",
"byte",
",",
"integer",
",",
"int",
"3",
"2",
",",
"int",
"6",
"4",
",",
"float",
",",
"string",
",",
"binary",
",",
"date",
",",
"date",
"time",
",",
"password",
",",
"param",
"callback",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
] |
[
"sets",
"the",
"default",
"{",
"@",
"link",
"delegation",
"token",
"authenticator",
"}",
"class",
"to",
"use",
"when",
"an",
"{",
"@",
"link",
"delegation",
"token",
"authenticated",
"u",
"r",
"l",
"}",
"instance",
"is",
"created",
"without",
"specifying",
"one",
"the",
"default",
"class",
"is",
"{",
"@",
"link",
"kerberos",
"delegation",
"token",
"authenticator",
"}"
] |
[
"public",
"static",
"void",
"set",
"default",
"delegation",
"token",
"authenticator",
"(",
"class",
"<",
"?",
"extends",
"delegation",
"token",
"authenticator",
">",
"authenticator",
")",
"{",
"default",
"authenticator",
"=",
"authenticator",
";",
"}"
] |
[
"user",
"who",
"has",
"started",
"the",
"zoo",
"keeper",
"server",
"user",
",",
"it",
"will",
"be",
"the",
"logged",
"-",
"in",
"user",
"if",
"no",
"user",
"logged",
"-",
"in",
"then",
"system",
"user"
] |
[
"public",
"static",
"string",
"get",
"z",
"k",
"user",
"(",
")",
"{",
"return",
"server",
"cnxn",
"factory",
"get",
"user",
"name",
"(",
")",
";",
"}"
] |
[
"returns",
"the",
"max",
"result",
"window",
"for",
"search",
"requests",
",",
"describing",
"the",
"maximum",
"value",
"of",
"from",
"+",
"size",
"on",
"a",
"query"
] |
[
"public",
"int",
"get",
"max",
"result",
"window",
"(",
")",
"{",
"return",
"this",
"max",
"result",
"window",
";",
"}"
] |
[
"gets",
"the",
"interprester",
"'",
"s",
"secondary",
"prompt"
] |
[
"synchronized",
"string",
"get",
"secondary",
"prompt",
"(",
")",
"{",
"return",
"get",
"system",
"state",
"(",
")",
"ps",
"2",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"return",
"the",
"additional",
"(",
"undeclared",
")",
"property",
"with",
"the",
"specified",
"name"
] |
[
"public",
"object",
"get",
"additional",
"property",
"(",
"string",
"key",
")",
"{",
"if",
"(",
"this",
"additional",
"properties",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"return",
"this",
"additional",
"properties",
"get",
"(",
"key",
")",
";",
"}"
] |
[
"get",
"the",
"domain",
"description"
] |
[
"public",
"string",
"get",
"description",
"(",
")",
"{",
"return",
"description",
";",
"}"
] |
[
"sets",
"whether",
"notifications",
"posted",
"to",
"this",
"channel",
"appear",
"on",
"the",
"lockscreen",
"or",
"not",
",",
"and",
"if",
"so",
",",
"whether",
"they",
"appear",
"in",
"a",
"redacted",
"form",
"see",
"e",
"g",
"{",
"@",
"link",
"notification",
"#",
"visibility",
"secret",
"}",
"only",
"modifiable",
"by",
"the",
"system",
"and",
"notification",
"ranker"
] |
[
"public",
"channel",
"config",
"set",
"lockscreen",
"visibility",
"(",
"int",
"lockscreen",
"visibility",
")",
"{",
"if",
"(",
"build",
"version",
"sdk",
"int",
">",
"=",
"build",
"version",
"codes",
"o",
")",
"{",
"m",
"notification",
"channel",
"set",
"lockscreen",
"visibility",
"(",
"lockscreen",
"visibility",
")",
";",
"}",
"return",
"this",
";",
"}"
] |
[
"<",
"code",
">",
"optional",
"bool",
"sex",
"=",
"5",
";",
"<",
"code",
">"
] |
[
"public",
"boolean",
"has",
"sex",
"(",
")",
"{",
"return",
"(",
"(",
"bit",
"field",
"0",
"&",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"1",
"0",
")",
"=",
"=",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"1",
"0",
")",
";",
"}"
] |
[
"evaluates",
"this",
"predicate",
"on",
"the",
"given",
"argument"
] |
[
"boolean",
"test",
"(",
"t",
"t",
")",
";"
] |
[
"create",
"a",
"new",
"{",
"@",
"link",
"channel",
"}",
"and",
"bind",
"it"
] |
[
"public",
"channel",
"future",
"bind",
"(",
"string",
"inet",
"host",
",",
"int",
"inet",
"port",
")",
"{",
"return",
"bind",
"(",
"socket",
"utils",
"socket",
"address",
"(",
"inet",
"host",
",",
"inet",
"port",
")",
")",
";",
"}"
] |
[
"increments",
"the",
"current",
"index",
"by",
"one",
"and",
"returns",
"the",
"character",
"at",
"the",
"new",
"index",
"if",
"the",
"resulting",
"index",
"is",
"greater",
"or",
"equal",
"to",
"the",
"end",
"index",
",",
"the",
"current",
"index",
"is",
"reset",
"to",
"the",
"end",
"index",
"and",
"a",
"value",
"of",
"done",
"is",
"returned",
"for",
"extended",
"reasons",
",",
"the",
"user",
"should",
"try",
"not",
"to",
"use",
"this",
"method",
"-",
"-",
"and",
"use",
"of",
"it",
"should",
"be",
"selective",
",",
"based",
"on",
"extended",
"class",
"reasons"
] |
[
"public",
"char",
"next",
"(",
")",
"{",
"debug",
"check",
"(",
"1",
")",
";",
"return",
"iter",
"next",
"(",
")",
";",
"}"
] |
[
"return",
"the",
"mac",
"address",
"must",
"hold",
"{",
"@",
"code",
"<",
"uses",
"-",
"permission",
"android",
":",
"name",
"=",
"\"",
"android",
"permission",
"access",
"wifi",
"state",
"\"",
">",
"}",
",",
"{",
"@",
"code",
"<",
"uses",
"-",
"permission",
"android",
":",
"name",
"=",
"\"",
"android",
"permission",
"internet",
"\"",
">",
"}"
] |
[
"public",
"static",
"string",
"get",
"mac",
"address",
"(",
"final",
"string",
"excepts",
")",
"{",
"string",
"mac",
"address",
"=",
"get",
"mac",
"address",
"by",
"network",
"interface",
"(",
")",
";",
"if",
"(",
"is",
"address",
"not",
"in",
"excepts",
"(",
"mac",
"address",
",",
"excepts",
")",
")",
"{",
"return",
"mac",
"address",
";",
"}",
"mac",
"address",
"=",
"get",
"mac",
"address",
"by",
"inet",
"address",
"(",
")",
";",
"if",
"(",
"is",
"address",
"not",
"in",
"excepts",
"(",
"mac",
"address",
",",
"excepts",
")",
")",
"{",
"return",
"mac",
"address",
";",
"}",
"mac",
"address",
"=",
"get",
"mac",
"address",
"by",
"wifi",
"info",
"(",
")",
";",
"if",
"(",
"is",
"address",
"not",
"in",
"excepts",
"(",
"mac",
"address",
",",
"excepts",
")",
")",
"{",
"return",
"mac",
"address",
";",
"}",
"mac",
"address",
"=",
"get",
"mac",
"address",
"by",
"file",
"(",
")",
";",
"if",
"(",
"is",
"address",
"not",
"in",
"excepts",
"(",
"mac",
"address",
",",
"excepts",
")",
")",
"{",
"return",
"mac",
"address",
";",
"}",
"return",
"\"",
"\"",
";",
"}"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"get",
"the",
"user",
"id"
] |
[
"public",
"string",
"get",
"user",
"(",
")",
"{",
"return",
"user",
";",
"}"
] |
[
"get",
"the",
"string",
"representation",
"for",
"the",
"files"
] |
[
"private",
"static",
"string",
"to",
"string",
"(",
"final",
"file",
"status",
"[",
"]",
"files",
")",
"{",
"final",
"string",
"builder",
"sb",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"sb",
"append",
"(",
"\"",
"[",
"\"",
")",
";",
"for",
"(",
"final",
"file",
"status",
"file",
":",
"files",
")",
"{",
"if",
"(",
"sb",
"length",
"(",
")",
">",
"1",
")",
"{",
"sb",
"append",
"(",
"\"",
",",
"\"",
")",
";",
"}",
"sb",
"append",
"(",
"path",
"get",
"path",
"without",
"scheme",
"and",
"authority",
"(",
"file",
"get",
"path",
"(",
")",
")",
")",
";",
"}",
"sb",
"append",
"(",
"\"",
"]",
"\"",
")",
";",
"return",
"sb",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"set",
"the",
"{",
"@",
"code",
"data",
"source",
"}",
",",
"typically",
"provided",
"via",
"dependency",
"injection",
"this",
"method",
"also",
"instantiates",
"the",
"{",
"@",
"link",
"#",
"jdbc",
"template",
"}",
"instance",
"variable"
] |
[
"public",
"void",
"set",
"data",
"source",
"(",
"data",
"source",
"data",
"source",
")",
"{",
"this",
"jdbc",
"template",
"set",
"data",
"source",
"(",
"data",
"source",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"uuid",
"'"
] |
[
"public",
"void",
"uuid",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"uuid",
"}"
] |
[
"test",
"2",
":",
"check",
"that",
"advanced",
"versioned",
"writable",
"works",
"(",
"well",
",",
"why",
"wouldn",
"'",
"t",
"it",
"!",
")"
] |
[
"public",
"void",
"test",
"advanced",
"versioned",
"writable",
"(",
")",
"throws",
"exception",
"{",
"test",
"writable",
"test",
"writable",
"(",
"new",
"advanced",
"versioned",
"writable",
"(",
")",
")",
";",
"}"
] |
[
"resets",
"component",
"this",
"will",
"drop",
"any",
"gesture",
"recognition",
"that",
"might",
"currently",
"be",
"in",
"progress"
] |
[
"public",
"void",
"reset",
"(",
")",
"{",
"m",
"is",
"capturing",
"gesture",
"=",
"false",
";",
"m",
"is",
"click",
"candidate",
"=",
"false",
";",
"}"
] |
[
"set",
"this",
"to",
"true",
"to",
"enable",
"logcat",
"outputs",
"for",
"the",
"chart",
"beware",
"that",
"logcat",
"output",
"decreases",
"rendering",
"performance",
"default",
":",
"disabled"
] |
[
"public",
"void",
"set",
"log",
"enabled",
"(",
"boolean",
"enabled",
")",
"{",
"m",
"log",
"enabled",
"=",
"enabled",
";",
"}"
] |
[
"http",
":",
"tools",
"ietf",
"orghtmldraft",
"-",
"ietf",
"-",
"httpbis",
"-",
"header",
"-",
"compression",
"-",
"12",
"#",
"appendix",
"-",
"c",
"2",
"4"
] |
[
"@",
"test",
"public",
"void",
"read",
"indexed",
"header",
"field",
"from",
"static",
"table",
"without",
"buffering",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"bytes",
"in",
"write",
"byte",
"(",
"0x",
"2",
"0",
")",
";",
"/",
"/",
"dynamic",
"table",
"size",
"update",
"(",
"size",
"=",
"0",
")",
"bytes",
"in",
"write",
"byte",
"(",
"0x",
"8",
"2",
")",
";",
"/",
"/",
"=",
"=",
"indexed",
"-",
"add",
"=",
"=",
"/",
"/",
"idx",
"=",
"2",
"-",
">",
":",
"method",
":",
"get",
"hpack",
"reader",
"read",
"headers",
"(",
")",
";",
"/",
"/",
"not",
"buffered",
"in",
"header",
"table",
"assert",
"equals",
"(",
"0",
",",
"hpack",
"reader",
"dynamic",
"table",
"header",
"count",
")",
";",
"assert",
"equals",
"(",
"header",
"entries",
"(",
"\"",
":",
"method",
"\"",
",",
"\"",
"get",
"\"",
")",
",",
"hpack",
"reader",
"get",
"and",
"reset",
"header",
"list",
"(",
")",
")",
";",
"}"
] |
[
"read",
"-",
"only",
":",
"returns",
"{",
"@",
"code",
"false",
"}"
] |
[
"public",
"boolean",
"can",
"write",
"(",
"evaluation",
"context",
"context",
",",
"@",
"nullable",
"object",
"target",
",",
"string",
"name",
")",
"throws",
"access",
"exception",
"{",
"return",
"false",
";",
"}"
] |
[
"if",
"set",
",",
"this",
"node",
"is",
"a",
"chunk",
"of",
"text",
"<",
"code",
">",
"optional",
"string",
"text",
"=",
"2",
";",
"<",
"code",
">"
] |
[
"public",
"builder",
"set",
"text",
"(",
"java",
"lang",
"string",
"value",
")",
"{",
"copy",
"on",
"write",
"(",
")",
";",
"instance",
"set",
"text",
"(",
"value",
")",
";",
"return",
"this",
";",
"}"
] |
[
"returns",
"the",
"rate",
"name",
"inside",
"the",
"metric"
] |
[
"public",
"string",
"get",
"queue",
"name",
"(",
"int",
"priority",
")",
"{",
"return",
"\"",
"decay",
"r",
"p",
"c",
"scheduler",
"priority",
"\"",
"+",
"priority",
"+",
"\"",
"rpc",
"queue",
"time",
"\"",
";",
"}"
] |
[
"gets",
"the",
"read",
"-",
"only",
"list",
"of",
"all",
"{",
"@",
"link",
"view",
"}",
"s"
] |
[
"public",
"collection",
"<",
"view",
">",
"get",
"views",
"(",
")",
"{",
"list",
"<",
"view",
">",
"orig",
"=",
"views",
"(",
")",
";",
"list",
"<",
"view",
">",
"copy",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"orig",
"size",
"(",
")",
")",
";",
"for",
"(",
"view",
"v",
":",
"orig",
")",
"{",
"if",
"(",
"v",
"has",
"permission",
"(",
"view",
"read",
")",
")",
"copy",
"add",
"(",
"v",
")",
";",
"}",
"copy",
"sort",
"(",
"view",
"sorter",
")",
";",
"return",
"copy",
";",
"}"
] |
[
"delete",
"purchase",
"order",
"by",
"id",
"for",
"valid",
"response",
"try",
"integer",
"i",
"ds",
"with",
"value",
"&",
"lt",
";",
"1000",
"anything",
"above",
"1000",
"or",
"nonintegers",
"will",
"generate",
"api",
"errors"
] |
[
"public",
"void",
"delete",
"order",
"test",
"(",
")",
"{",
"string",
"order",
"id",
"=",
"null",
";",
"api",
"delete",
"order",
"(",
"order",
"id",
")",
";",
"/",
"/",
"todo",
":",
"test",
"validations",
"}"
] |
[
"calculates",
"a",
"sensible",
"default",
"frequency",
"for",
"a",
"given",
"bucket",
"span",
"the",
"default",
"depends",
"on",
"the",
"bucket",
"span",
":",
"&",
"lt",
";",
"=",
"2",
"mins",
"-",
"&",
"gt",
";",
"1",
"min",
"&",
"lt",
";",
"=",
"20",
"mins",
"-",
"&",
"gt",
";",
"bucket",
"span",
"2",
"&",
"lt",
";",
"=",
"12",
"hours",
"-",
"&",
"gt",
";",
"10",
"mins",
"&",
"gt",
";",
"12",
"hours",
"-",
"&",
"gt",
";",
"1",
"hour",
"if",
"the",
"datafeed",
"has",
"aggregations",
",",
"the",
"default",
"frequency",
"is",
"the",
"closest",
"multiple",
"of",
"the",
"histogram",
"interval",
"based",
"on",
"the",
"rules",
"above"
] |
[
"public",
"time",
"value",
"default",
"frequency",
"(",
"time",
"value",
"bucket",
"span",
",",
"named",
"x",
"content",
"registry",
"x",
"content",
"registry",
")",
"{",
"time",
"value",
"default",
"frequency",
"=",
"default",
"frequency",
"target",
"(",
"bucket",
"span",
")",
";",
"if",
"(",
"has",
"aggregations",
"(",
")",
")",
"{",
"long",
"histogram",
"interval",
"millis",
"=",
"get",
"histogram",
"interval",
"millis",
"(",
"x",
"content",
"registry",
")",
";",
"long",
"target",
"frequency",
"millis",
"=",
"default",
"frequency",
"millis",
"(",
")",
";",
"long",
"default",
"frequency",
"millis",
"=",
"histogram",
"interval",
"millis",
">",
"target",
"frequency",
"millis",
"?",
"histogram",
"interval",
"millis",
":",
"(",
"target",
"frequency",
"millis",
"/",
"histogram",
"interval",
"millis",
")",
"*",
"histogram",
"interval",
"millis",
";",
"default",
"frequency",
"=",
"time",
"value",
"time",
"value",
"millis",
"(",
"default",
"frequency",
"millis",
")",
";",
"}",
"return",
"default",
"frequency",
";",
"}"
] |
[
"parses",
"a",
"raw",
"string",
"into",
"{",
"@",
"link",
"bootstrap",
"info",
"}"
] |
[
"static",
"bootstrap",
"info",
"parse",
"config",
"(",
"string",
"raw",
"data",
")",
"throws",
"xds",
"initialization",
"exception",
"{",
"xds",
"logger",
"logger",
"=",
"xds",
"logger",
"with",
"prefix",
"(",
"log",
"prefix",
")",
";",
"logger",
"log",
"(",
"xds",
"log",
"level",
"info",
",",
"\"",
"reading",
"bootstrap",
"information",
"\"",
")",
";",
"map",
"<",
"string",
",",
"?",
">",
"raw",
"bootstrap",
";",
"try",
"{",
"raw",
"bootstrap",
"=",
"(",
"map",
"<",
"string",
",",
"?",
">",
")",
"json",
"parser",
"parse",
"(",
"raw",
"data",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"throw",
"new",
"xds",
"initialization",
"exception",
"(",
"\"",
"failed",
"to",
"parse",
"json",
"\"",
",",
"e",
")",
";",
"}",
"logger",
"log",
"(",
"xds",
"log",
"level",
"debug",
",",
"\"",
"bootstrap",
"configuration",
":",
"\\",
"n",
"{",
"0",
"}",
"\"",
",",
"raw",
"bootstrap",
")",
";",
"list",
"<",
"server",
"info",
">",
"servers",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"list",
"<",
"?",
">",
"raw",
"server",
"configs",
"=",
"json",
"util",
"get",
"list",
"(",
"raw",
"bootstrap",
",",
"\"",
"xds",
"servers",
"\"",
")",
";",
"if",
"(",
"raw",
"server",
"configs",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"xds",
"initialization",
"exception",
"(",
"\"",
"invalid",
"bootstrap",
":",
"'",
"xds",
"servers",
"'",
"does",
"not",
"exist",
"\"",
")",
";",
"}",
"logger",
"log",
"(",
"xds",
"log",
"level",
"info",
",",
"\"",
"configured",
"with",
"{",
"0",
"}",
"x",
"d",
"s",
"servers",
"\"",
",",
"raw",
"server",
"configs",
"size",
"(",
")",
")",
";",
"/",
"/",
"todo",
"(",
"chengyuanzhang",
")",
":",
"require",
"at",
"least",
"one",
"server",
"uri",
"list",
"<",
"map",
"<",
"string",
",",
"?",
">",
">",
"server",
"config",
"list",
"=",
"json",
"util",
"check",
"object",
"list",
"(",
"raw",
"server",
"configs",
")",
";",
"for",
"(",
"map",
"<",
"string",
",",
"?",
">",
"server",
"config",
":",
"server",
"config",
"list",
")",
"{",
"string",
"server",
"uri",
"=",
"json",
"util",
"get",
"string",
"(",
"server",
"config",
",",
"\"",
"server",
"uri",
"\"",
")",
";",
"if",
"(",
"server",
"uri",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"xds",
"initialization",
"exception",
"(",
"\"",
"invalid",
"bootstrap",
":",
"missing",
"'",
"server",
"uri",
"'",
"\"",
")",
";",
"}",
"logger",
"log",
"(",
"xds",
"log",
"level",
"info",
",",
"\"",
"x",
"d",
"s",
"server",
"uri",
":",
"{",
"0",
"}",
"\"",
",",
"server",
"uri",
")",
";",
"list",
"<",
"?",
">",
"raw",
"channel",
"creds",
"list",
"=",
"json",
"util",
"get",
"list",
"(",
"server",
"config",
",",
"\"",
"channel",
"creds",
"\"",
")",
";",
"if",
"(",
"raw",
"channel",
"creds",
"list",
"=",
"=",
"null",
"|",
"|",
"raw",
"channel",
"creds",
"list",
"is",
"empty",
"(",
")",
")",
"{",
"throw",
"new",
"xds",
"initialization",
"exception",
"(",
"\"",
"invalid",
"bootstrap",
":",
"server",
"\"",
"+",
"server",
"uri",
"+",
"\"",
"'",
"channel",
"creds",
"'",
"required",
"\"",
")",
";",
"}",
"channel",
"credentials",
"channel",
"credentials",
"=",
"parse",
"channel",
"credentials",
"(",
"json",
"util",
"check",
"object",
"list",
"(",
"raw",
"channel",
"creds",
"list",
")",
",",
"server",
"uri",
")",
";",
"if",
"(",
"channel",
"credentials",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"xds",
"initialization",
"exception",
"(",
"\"",
"server",
"\"",
"+",
"server",
"uri",
"+",
"\"",
":",
"no",
"supported",
"channel",
"credentials",
"found",
"\"",
")",
";",
"}",
"boolean",
"use",
"protocol",
"v",
"3",
"=",
"false",
";",
"list",
"<",
"string",
">",
"server",
"features",
"=",
"json",
"util",
"get",
"list",
"of",
"strings",
"(",
"server",
"config",
",",
"\"",
"server",
"features",
"\"",
")",
";",
"if",
"(",
"server",
"features",
"!",
"=",
"null",
")",
"{",
"logger",
"log",
"(",
"xds",
"log",
"level",
"info",
",",
"\"",
"server",
"features",
":",
"{",
"0",
"}",
"\"",
",",
"server",
"features",
")",
";",
"use",
"protocol",
"v",
"3",
"=",
"enable",
"v",
"3",
"protocol",
"&",
"&",
"server",
"features",
"contains",
"(",
"xds",
"v3",
"server",
"feature",
")",
";",
"}",
"servers",
"add",
"(",
"new",
"server",
"info",
"(",
"server",
"uri",
",",
"channel",
"credentials",
",",
"use",
"protocol",
"v",
"3",
")",
")",
";",
"}",
"node",
"builder",
"node",
"builder",
"=",
"node",
"new",
"builder",
"(",
")",
";",
"map",
"<",
"string",
",",
"?",
">",
"raw",
"node",
"=",
"json",
"util",
"get",
"object",
"(",
"raw",
"bootstrap",
",",
"\"",
"node",
"\"",
")",
";",
"if",
"(",
"raw",
"node",
"!",
"=",
"null",
")",
"{",
"string",
"id",
"=",
"json",
"util",
"get",
"string",
"(",
"raw",
"node",
",",
"\"",
"id",
"\"",
")",
";",
"if",
"(",
"id",
"!",
"=",
"null",
")",
"{",
"logger",
"log",
"(",
"xds",
"log",
"level",
"info",
",",
"\"",
"node",
"id",
":",
"{",
"0",
"}",
"\"",
",",
"id",
")",
";",
"node",
"builder",
"set",
"id",
"(",
"id",
")",
";",
"}",
"string",
"cluster",
"=",
"json",
"util",
"get",
"string",
"(",
"raw",
"node",
",",
"\"",
"cluster",
"\"",
")",
";",
"if",
"(",
"cluster",
"!",
"=",
"null",
")",
"{",
"logger",
"log",
"(",
"xds",
"log",
"level",
"info",
",",
"\"",
"node",
"cluster",
":",
"{",
"0",
"}",
"\"",
",",
"cluster",
")",
";",
"node",
"builder",
"set",
"cluster",
"(",
"cluster",
")",
";",
"}",
"map",
"<",
"string",
",",
"?",
">",
"metadata",
"=",
"json",
"util",
"get",
"object",
"(",
"raw",
"node",
",",
"\"",
"metadata",
"\"",
")",
";",
"if",
"(",
"metadata",
"!",
"=",
"null",
")",
"{",
"node",
"builder",
"set",
"metadata",
"(",
"metadata",
")",
";",
"}",
"map",
"<",
"string",
",",
"?",
">",
"raw",
"locality",
"=",
"json",
"util",
"get",
"object",
"(",
"raw",
"node",
",",
"\"",
"locality",
"\"",
")",
";",
"if",
"(",
"raw",
"locality",
"!",
"=",
"null",
")",
"{",
"string",
"region",
"=",
"json",
"util",
"get",
"string",
"(",
"raw",
"locality",
",",
"\"",
"region",
"\"",
")",
";",
"string",
"zone",
"=",
"json",
"util",
"get",
"string",
"(",
"raw",
"locality",
",",
"\"",
"zone",
"\"",
")",
";",
"string",
"sub",
"zone",
"=",
"json",
"util",
"get",
"string",
"(",
"raw",
"locality",
",",
"\"",
"sub",
"zone",
"\"",
")",
";",
"if",
"(",
"region",
"!",
"=",
"null",
")",
"{",
"logger",
"log",
"(",
"xds",
"log",
"level",
"info",
",",
"\"",
"locality",
"region",
":",
"{",
"0",
"}",
"\"",
",",
"region",
")",
";",
"}",
"if",
"(",
"raw",
"locality",
"contains",
"key",
"(",
"\"",
"zone",
"\"",
")",
")",
"{",
"logger",
"log",
"(",
"xds",
"log",
"level",
"info",
",",
"\"",
"locality",
"zone",
":",
"{",
"0",
"}",
"\"",
",",
"zone",
")",
";",
"}",
"if",
"(",
"raw",
"locality",
"contains",
"key",
"(",
"\"",
"sub",
"zone",
"\"",
")",
")",
"{",
"logger",
"log",
"(",
"xds",
"log",
"level",
"info",
",",
"\"",
"locality",
"sub",
"zone",
":",
"{",
"0",
"}",
"\"",
",",
"sub",
"zone",
")",
";",
"}",
"locality",
"locality",
"=",
"new",
"locality",
"(",
"region",
",",
"zone",
",",
"sub",
"zone",
")",
";",
"node",
"builder",
"set",
"locality",
"(",
"locality",
")",
";",
"}",
"}",
"grpc",
"build",
"version",
"build",
"version",
"=",
"grpc",
"util",
"get",
"grpc",
"build",
"version",
"(",
")",
";",
"logger",
"log",
"(",
"xds",
"log",
"level",
"info",
",",
"\"",
"build",
"version",
":",
"{",
"0",
"}",
"\"",
",",
"build",
"version",
")",
";",
"node",
"builder",
"set",
"build",
"version",
"(",
"build",
"version",
"to",
"string",
"(",
")",
")",
";",
"node",
"builder",
"set",
"user",
"agent",
"name",
"(",
"build",
"version",
"get",
"user",
"agent",
"(",
")",
")",
";",
"node",
"builder",
"set",
"user",
"agent",
"version",
"(",
"build",
"version",
"get",
"implementation",
"version",
"(",
")",
")",
";",
"node",
"builder",
"add",
"client",
"features",
"(",
"client",
"feature",
"disable",
"overprovisioning",
")",
";",
"map",
"<",
"string",
",",
"?",
">",
"cert",
"providers",
"blob",
"=",
"json",
"util",
"get",
"object",
"(",
"raw",
"bootstrap",
",",
"\"",
"certificate",
"providers",
"\"",
")",
";",
"map",
"<",
"string",
",",
"certificate",
"provider",
"info",
">",
"cert",
"providers",
"=",
"null",
";",
"if",
"(",
"cert",
"providers",
"blob",
"!",
"=",
"null",
")",
"{",
"cert",
"providers",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
"cert",
"providers",
"blob",
"size",
"(",
")",
")",
";",
"for",
"(",
"string",
"name",
":",
"cert",
"providers",
"blob",
"key",
"set",
"(",
")",
")",
"{",
"map",
"<",
"string",
",",
"?",
">",
"value",
"map",
"=",
"json",
"util",
"get",
"object",
"(",
"cert",
"providers",
"blob",
",",
"name",
")",
";",
"string",
"plugin",
"name",
"=",
"check",
"for",
"null",
"(",
"json",
"util",
"get",
"string",
"(",
"value",
"map",
",",
"\"",
"plugin",
"name",
"\"",
")",
",",
"\"",
"plugin",
"name",
"\"",
")",
";",
"map",
"<",
"string",
",",
"?",
">",
"config",
"=",
"check",
"for",
"null",
"(",
"json",
"util",
"get",
"object",
"(",
"value",
"map",
",",
"\"",
"config",
"\"",
")",
",",
"\"",
"config",
"\"",
")",
";",
"certificate",
"provider",
"info",
"certificate",
"provider",
"info",
"=",
"new",
"certificate",
"provider",
"info",
"(",
"plugin",
"name",
",",
"config",
")",
";",
"cert",
"providers",
"put",
"(",
"name",
",",
"certificate",
"provider",
"info",
")",
";",
"}",
"}",
"string",
"grpc",
"server",
"resource",
"id",
"=",
"json",
"util",
"get",
"string",
"(",
"raw",
"bootstrap",
",",
"\"",
"grpc",
"server",
"resource",
"name",
"id",
"\"",
")",
";",
"return",
"new",
"bootstrap",
"info",
"(",
"servers",
",",
"node",
"builder",
"build",
"(",
")",
",",
"cert",
"providers",
",",
"grpc",
"server",
"resource",
"id",
")",
";",
"}"
] |
[
"see",
"{",
"@",
"link",
"kafka",
"producer",
"#",
"send",
"(",
"producer",
"record",
",",
"callback",
")",
"}"
] |
[
"future",
"<",
"record",
"metadata",
">",
"send",
"(",
"producer",
"record",
"<",
"k",
",",
"v",
">",
"record",
",",
"callback",
"callback",
")",
";"
] |
[
"decodes",
"image",
"to",
"{",
"@",
"link",
"bitmap",
"}",
"according",
"target",
"size",
"and",
"other",
"parameters"
] |
[
"bitmap",
"decode",
"(",
"image",
"decoding",
"info",
"image",
"decoding",
"info",
")",
"throws",
"i",
"o",
"exception",
";"
] |
[
"returns",
"the",
"hash",
"code",
"of",
"{",
"@",
"code",
"type",
"}"
] |
[
"public",
"static",
"int",
"hash",
"code",
"(",
"type",
"type",
")",
"{",
"if",
"(",
"type",
"instanceof",
"class",
")",
"{",
"/",
"/",
"class",
"specifies",
"hash",
"code",
"(",
")",
"return",
"type",
"hash",
"code",
"(",
")",
";",
"}",
"else",
"if",
"(",
"type",
"instanceof",
"parameterized",
"type",
")",
"{",
"parameterized",
"type",
"p",
"=",
"(",
"parameterized",
"type",
")",
"type",
";",
"return",
"arrays",
"hash",
"code",
"(",
"p",
"get",
"actual",
"type",
"arguments",
"(",
")",
")",
"^",
"p",
"get",
"raw",
"type",
"(",
")",
"hash",
"code",
"(",
")",
"^",
"hash",
"code",
"or",
"zero",
"(",
"p",
"get",
"owner",
"type",
"(",
")",
")",
";",
"}",
"else",
"if",
"(",
"type",
"instanceof",
"generic",
"array",
"type",
")",
"{",
"return",
"hash",
"code",
"(",
"(",
"(",
"generic",
"array",
"type",
")",
"type",
")",
"get",
"generic",
"component",
"type",
"(",
")",
")",
";",
"}",
"else",
"if",
"(",
"type",
"instanceof",
"wildcard",
"type",
")",
"{",
"wildcard",
"type",
"w",
"=",
"(",
"wildcard",
"type",
")",
"type",
";",
"return",
"arrays",
"hash",
"code",
"(",
"w",
"get",
"lower",
"bounds",
"(",
")",
")",
"^",
"arrays",
"hash",
"code",
"(",
"w",
"get",
"upper",
"bounds",
"(",
")",
")",
";",
"}",
"else",
"{",
"/",
"/",
"this",
"isn",
"'",
"t",
"a",
"type",
"we",
"support",
"probably",
"a",
"type",
"variable",
"return",
"hash",
"code",
"or",
"zero",
"(",
"type",
")",
";",
"}",
"}"
] |
[
"get",
"processor",
"language",
"module",
"associated",
"with",
"this",
"prototype"
] |
[
"public",
"language",
"get",
"language",
"(",
")",
";"
] |
[
"same",
"with",
"{",
"@",
"link",
"#",
"slice",
"(",
"int",
",",
"int",
")",
"}",
"except",
"that",
"this",
"method",
"returns",
"a",
"list"
] |
[
"public",
"list",
"<",
"byte",
"buf",
">",
"decompose",
"(",
"int",
"offset",
",",
"int",
"length",
")",
"{",
"check",
"index",
"(",
"offset",
",",
"length",
")",
";",
"if",
"(",
"length",
"=",
"=",
"0",
")",
"{",
"return",
"collections",
"empty",
"list",
"(",
")",
";",
"}",
"int",
"component",
"id",
"=",
"to",
"component",
"index",
"0",
"(",
"offset",
")",
";",
"int",
"bytes",
"to",
"slice",
"=",
"length",
";",
"/",
"/",
"the",
"first",
"component",
"component",
"first",
"c",
"=",
"components",
"[",
"component",
"id",
"]",
";",
"byte",
"buf",
"slice",
"=",
"first",
"c",
"buf",
"slice",
"(",
"first",
"c",
"idx",
"(",
"offset",
")",
",",
"math",
"min",
"(",
"first",
"c",
"end",
"offset",
"-",
"offset",
",",
"bytes",
"to",
"slice",
")",
")",
";",
"bytes",
"to",
"slice",
"-",
"=",
"slice",
"readable",
"bytes",
"(",
")",
";",
"if",
"(",
"bytes",
"to",
"slice",
"=",
"=",
"0",
")",
"{",
"return",
"collections",
"singleton",
"list",
"(",
"slice",
")",
";",
"}",
"list",
"<",
"byte",
"buf",
">",
"slice",
"list",
"=",
"new",
"array",
"list",
"<",
"byte",
"buf",
">",
"(",
"component",
"count",
"-",
"component",
"id",
")",
";",
"slice",
"list",
"add",
"(",
"slice",
")",
";",
"/",
"/",
"add",
"all",
"the",
"slices",
"until",
"there",
"is",
"nothing",
"more",
"left",
"and",
"then",
"return",
"the",
"list",
"do",
"{",
"component",
"component",
"=",
"components",
"[",
"+",
"+",
"component",
"id",
"]",
";",
"slice",
"=",
"component",
"buf",
"slice",
"(",
"component",
"idx",
"(",
"component",
"offset",
")",
",",
"math",
"min",
"(",
"component",
"length",
"(",
")",
",",
"bytes",
"to",
"slice",
")",
")",
";",
"bytes",
"to",
"slice",
"-",
"=",
"slice",
"readable",
"bytes",
"(",
")",
";",
"slice",
"list",
"add",
"(",
"slice",
")",
";",
"}",
"while",
"(",
"bytes",
"to",
"slice",
">",
"0",
")",
";",
"return",
"slice",
"list",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"double",
"'"
] |
[
"public",
"void",
"double",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"double",
"}"
] |
[
"returns",
"true",
"if",
"this",
"insn",
"has",
"a",
"side",
"-",
"effect",
"returns",
"true",
"if",
"the",
"insn",
"is",
"null",
"for",
"reasons",
"stated",
"in",
"the",
"code",
"block"
] |
[
"private",
"static",
"boolean",
"has",
"side",
"effect",
"(",
"ssa",
"insn",
"insn",
")",
"{",
"if",
"(",
"insn",
"=",
"=",
"null",
")",
"{",
"/",
"*",
"while",
"false",
"would",
"seem",
"to",
"make",
"more",
"sense",
"here",
",",
"true",
"*",
"prevents",
"us",
"from",
"adding",
"this",
"back",
"to",
"a",
"worklist",
"unnecessarally",
"*",
"/",
"return",
"true",
";",
"}",
"return",
"insn",
"has",
"side",
"effect",
"(",
")",
";",
"}"
] |
[
"get",
"integer",
"item"
] |
[
"public",
"integer",
"get",
"integer",
"item",
"(",
")",
"{",
"return",
"integer",
"item",
";",
"}"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"visits",
"an",
"annotation",
"of",
"a",
"parameter",
"this",
"method"
] |
[
"public",
"annotation",
"visitor",
"visit",
"parameter",
"annotation",
"(",
"final",
"int",
"parameter",
",",
"final",
"string",
"descriptor",
",",
"final",
"boolean",
"visible",
")",
"{",
"if",
"(",
"mv",
"!",
"=",
"null",
")",
"{",
"return",
"mv",
"visit",
"parameter",
"annotation",
"(",
"parameter",
",",
"descriptor",
",",
"visible",
")",
";",
"}",
"return",
"null",
";",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.