docstring_tokens
list | code_tokens
list |
|---|---|
[
"gets",
"the",
"version",
"of",
"the",
"given",
"java",
"executable",
"from",
"the",
"output",
"of",
"running",
"\"",
"java",
"-",
"version",
"\""
] |
[
"private",
"java",
"version",
"run",
"and",
"get",
"java",
"version",
"(",
"file",
"java",
"executable",
")",
"throws",
"parse",
"exception",
",",
"i",
"o",
"exception",
"{",
"string",
"version",
"=",
"\"",
"\"",
";",
"string",
"arch",
"=",
"\"",
"\"",
";",
"process",
"proc",
"=",
"runtime",
"get",
"runtime",
"(",
")",
"exec",
"(",
"new",
"string",
"[",
"]",
"{",
"java",
"executable",
"get",
"absolute",
"path",
"(",
")",
",",
"\"",
"-",
"xshow",
"settings",
":",
"properties",
"\"",
",",
"\"",
"-",
"version",
"\"",
"}",
")",
";",
"try",
"(",
"buffered",
"reader",
"reader",
"=",
"new",
"buffered",
"reader",
"(",
"new",
"input",
"stream",
"reader",
"(",
"proc",
"get",
"error",
"stream",
"(",
")",
")",
")",
")",
"{",
"string",
"line",
";",
"while",
"(",
"(",
"version",
"is",
"empty",
"(",
")",
"|",
"|",
"arch",
"is",
"empty",
"(",
")",
")",
"&",
"&",
"(",
"line",
"=",
"reader",
"read",
"line",
"(",
")",
")",
"!",
"=",
"null",
")",
"{",
"line",
"=",
"line",
"trim",
"(",
")",
";",
"string",
"search",
"string",
"=",
"\"",
"java",
"version",
"=",
"\"",
";",
"if",
"(",
"line",
"starts",
"with",
"(",
"search",
"string",
")",
")",
"{",
"version",
"=",
"line",
"substring",
"(",
"search",
"string",
"length",
"(",
")",
")",
";",
"}",
"search",
"string",
"=",
"\"",
"sun",
"arch",
"data",
"model",
"=",
"\"",
";",
"if",
"(",
"line",
"starts",
"with",
"(",
"search",
"string",
")",
")",
"{",
"arch",
"=",
"line",
"substring",
"(",
"search",
"string",
"length",
"(",
")",
")",
";",
"}",
"}",
"}",
"if",
"(",
"version",
"is",
"empty",
"(",
")",
")",
"{",
"throw",
"new",
"parse",
"exception",
"(",
"\"",
"failed",
"to",
"find",
"java",
"version",
"\"",
",",
"0",
")",
";",
"}",
"if",
"(",
"arch",
"is",
"empty",
"(",
")",
")",
"{",
"throw",
"new",
"parse",
"exception",
"(",
"\"",
"failed",
"to",
"find",
"java",
"architecture",
"\"",
",",
"0",
")",
";",
"}",
"return",
"new",
"java",
"version",
"(",
"version",
",",
"arch",
")",
";",
"}"
] |
[
"return",
"the",
"application",
"'",
"s",
"height",
"of",
"screen",
",",
"in",
"pixel"
] |
[
"public",
"static",
"int",
"get",
"app",
"screen",
"height",
"(",
")",
"{",
"window",
"manager",
"wm",
"=",
"(",
"window",
"manager",
")",
"utils",
"get",
"app",
"(",
")",
"get",
"system",
"service",
"(",
"context",
"window",
"service",
")",
";",
"if",
"(",
"wm",
"=",
"=",
"null",
")",
"return",
"-",
"1",
";",
"point",
"point",
"=",
"new",
"point",
"(",
")",
";",
"wm",
"get",
"default",
"display",
"(",
")",
"get",
"size",
"(",
"point",
")",
";",
"return",
"point",
"y",
";",
"}"
] |
[
"creates",
"a",
"graph",
"from",
"a",
"data",
"set",
"of",
"edges",
"vertices",
"are",
"created",
"automatically",
"and",
"their",
"values",
"are",
"set",
"to",
"null",
"value"
] |
[
"public",
"static",
"<",
"k",
",",
"ev",
">",
"graph",
"<",
"k",
",",
"null",
"value",
",",
"ev",
">",
"from",
"data",
"set",
"(",
"data",
"set",
"<",
"edge",
"<",
"k",
",",
"ev",
">",
">",
"edges",
",",
"execution",
"environment",
"context",
")",
"{",
"data",
"set",
"<",
"vertex",
"<",
"k",
",",
"null",
"value",
">",
">",
"vertices",
"=",
"edges",
"flat",
"map",
"(",
"new",
"emit",
"src",
"and",
"target",
"<",
">",
"(",
")",
")",
"name",
"(",
"\"",
"source",
"and",
"target",
"i",
"ds",
"\"",
")",
"distinct",
"(",
")",
"name",
"(",
"\"",
"i",
"ds",
"\"",
")",
";",
"return",
"new",
"graph",
"<",
">",
"(",
"vertices",
",",
"edges",
",",
"context",
")",
";",
"}"
] |
[
"overridden",
"method",
"that",
"simply",
"returns",
"{",
"@",
"code",
"null",
"}",
"when",
"no",
"servlet",
"config",
"set",
"yet"
] |
[
"public",
"string",
"get",
"servlet",
"name",
"(",
")",
"{",
"return",
"(",
"get",
"servlet",
"config",
"(",
")",
"!",
"=",
"null",
"?",
"get",
"servlet",
"config",
"(",
")",
"get",
"servlet",
"name",
"(",
")",
":",
"null",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"double",
"'"
] |
[
"public",
"void",
"double",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"double",
"}"
] |
[
"gets",
"whether",
"to",
"decode",
"a",
"preview",
"frame",
"for",
"animated",
"images"
] |
[
"public",
"boolean",
"get",
"decode",
"preview",
"frame",
"(",
")",
"{",
"return",
"m",
"decode",
"preview",
"frame",
";",
"}"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"method",
"supporting",
"the",
"meta",
"-",
"data",
"processing",
"for",
"a",
"table",
"'",
"s",
"columns"
] |
[
"private",
"void",
"process",
"table",
"columns",
"(",
"database",
"meta",
"data",
"database",
"meta",
"data",
",",
"table",
"meta",
"data",
"tmd",
")",
"{",
"result",
"set",
"table",
"columns",
"=",
"null",
";",
"string",
"meta",
"data",
"catalog",
"name",
"=",
"meta",
"data",
"catalog",
"name",
"to",
"use",
"(",
"tmd",
"get",
"catalog",
"name",
"(",
")",
")",
";",
"string",
"meta",
"data",
"schema",
"name",
"=",
"meta",
"data",
"schema",
"name",
"to",
"use",
"(",
"tmd",
"get",
"schema",
"name",
"(",
")",
")",
";",
"string",
"meta",
"data",
"table",
"name",
"=",
"table",
"name",
"to",
"use",
"(",
"tmd",
"get",
"table",
"name",
"(",
")",
")",
";",
"if",
"(",
"logger",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"logger",
"debug",
"(",
"\"",
"retrieving",
"meta",
"-",
"data",
"for",
"\"",
"+",
"meta",
"data",
"catalog",
"name",
"+",
"'",
"/",
"'",
"+",
"meta",
"data",
"schema",
"name",
"+",
"'",
"/",
"'",
"+",
"meta",
"data",
"table",
"name",
")",
";",
"}",
"try",
"{",
"table",
"columns",
"=",
"database",
"meta",
"data",
"get",
"columns",
"(",
"meta",
"data",
"catalog",
"name",
",",
"meta",
"data",
"schema",
"name",
",",
"meta",
"data",
"table",
"name",
",",
"null",
")",
";",
"while",
"(",
"table",
"columns",
"next",
"(",
")",
")",
"{",
"string",
"column",
"name",
"=",
"table",
"columns",
"get",
"string",
"(",
"\"",
"column",
"name",
"\"",
")",
";",
"int",
"data",
"type",
"=",
"table",
"columns",
"get",
"int",
"(",
"\"",
"data",
"type",
"\"",
")",
";",
"if",
"(",
"data",
"type",
"=",
"=",
"types",
"decimal",
")",
"{",
"string",
"type",
"name",
"=",
"table",
"columns",
"get",
"string",
"(",
"\"",
"type",
"name",
"\"",
")",
";",
"int",
"decimal",
"digits",
"=",
"table",
"columns",
"get",
"int",
"(",
"\"",
"decimal",
"digits",
"\"",
")",
";",
"/",
"/",
"override",
"a",
"decimal",
"data",
"type",
"for",
"no",
"-",
"decimal",
"numerics",
"/",
"/",
"(",
"this",
"is",
"for",
"better",
"oracle",
"support",
"where",
"there",
"have",
"been",
"issues",
"/",
"/",
"using",
"decimal",
"for",
"certain",
"inserts",
"(",
"see",
"spr",
"-",
"6912",
")",
")",
"if",
"(",
"\"",
"number",
"\"",
"equals",
"(",
"type",
"name",
")",
"&",
"&",
"decimal",
"digits",
"=",
"=",
"0",
")",
"{",
"data",
"type",
"=",
"types",
"numeric",
";",
"if",
"(",
"logger",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"logger",
"debug",
"(",
"\"",
"overriding",
"meta",
"-",
"data",
":",
"\"",
"+",
"column",
"name",
"+",
"\"",
"now",
"numeric",
"instead",
"of",
"decimal",
"\"",
")",
";",
"}",
"}",
"}",
"boolean",
"nullable",
"=",
"table",
"columns",
"get",
"boolean",
"(",
"\"",
"nullable",
"\"",
")",
";",
"table",
"parameter",
"meta",
"data",
"meta",
"=",
"new",
"table",
"parameter",
"meta",
"data",
"(",
"column",
"name",
",",
"data",
"type",
",",
"nullable",
")",
";",
"this",
"table",
"parameter",
"meta",
"data",
"add",
"(",
"meta",
")",
";",
"if",
"(",
"logger",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"logger",
"debug",
"(",
"\"",
"retrieved",
"meta",
"-",
"data",
":",
"'",
"\"",
"+",
"meta",
"get",
"parameter",
"name",
"(",
")",
"+",
"\"",
"'",
",",
"sql",
"type",
"=",
"\"",
"+",
"meta",
"get",
"sql",
"type",
"(",
")",
"+",
"\"",
",",
"nullable",
"=",
"\"",
"+",
"meta",
"is",
"nullable",
"(",
")",
")",
";",
"}",
"}",
"}",
"catch",
"(",
"s",
"q",
"l",
"exception",
"ex",
")",
"{",
"if",
"(",
"logger",
"is",
"warn",
"enabled",
"(",
")",
")",
"{",
"logger",
"warn",
"(",
"\"",
"error",
"while",
"retrieving",
"meta",
"-",
"data",
"for",
"table",
"columns",
":",
"\"",
"+",
"ex",
"get",
"message",
"(",
")",
")",
";",
"}",
"}",
"finally",
"{",
"jdbc",
"utils",
"close",
"result",
"set",
"(",
"table",
"columns",
")",
";",
"}",
"}"
] |
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
] |
[
"private",
"string",
"to",
"indented",
"string",
"(",
"java",
"lang",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"tests",
"that",
"concurrent",
"accesses",
"only",
"trigger",
"a",
"single",
"access",
"execution",
"graph",
"request"
] |
[
"public",
"void",
"test",
"concurrent",
"access",
"(",
")",
"throws",
"exception",
"{",
"final",
"time",
"timeout",
"=",
"time",
"milliseconds",
"(",
"100l",
")",
";",
"final",
"time",
"time",
"to",
"live",
"=",
"time",
"hours",
"(",
"1l",
")",
";",
"final",
"counting",
"restful",
"gateway",
"restful",
"gateway",
"=",
"create",
"counting",
"restful",
"gateway",
"(",
"expected",
"job",
"id",
",",
"completable",
"future",
"completed",
"future",
"(",
"expected",
"execution",
"graph",
")",
")",
";",
"final",
"int",
"num",
"concurrent",
"accesses",
"=",
"10",
";",
"final",
"array",
"list",
"<",
"completable",
"future",
"<",
"access",
"execution",
"graph",
">",
">",
"execution",
"graph",
"futures",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"num",
"concurrent",
"accesses",
")",
";",
"final",
"executor",
"service",
"executor",
"=",
"java",
"util",
"concurrent",
"executors",
"new",
"fixed",
"thread",
"pool",
"(",
"num",
"concurrent",
"accesses",
")",
";",
"try",
"(",
"execution",
"graph",
"cache",
"execution",
"graph",
"cache",
"=",
"new",
"default",
"execution",
"graph",
"cache",
"(",
"timeout",
",",
"time",
"to",
"live",
")",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"num",
"concurrent",
"accesses",
";",
"i",
"+",
"+",
")",
"{",
"completable",
"future",
"<",
"access",
"execution",
"graph",
">",
"execution",
"graph",
"future",
"=",
"completable",
"future",
"supply",
"async",
"(",
"(",
")",
"-",
">",
"execution",
"graph",
"cache",
"get",
"execution",
"graph",
"(",
"expected",
"job",
"id",
",",
"restful",
"gateway",
")",
",",
"executor",
")",
"then",
"compose",
"(",
"function",
"identity",
"(",
")",
")",
";",
"execution",
"graph",
"futures",
"add",
"(",
"execution",
"graph",
"future",
")",
";",
"}",
"final",
"completable",
"future",
"<",
"collection",
"<",
"access",
"execution",
"graph",
">",
">",
"all",
"execution",
"graph",
"futures",
"=",
"future",
"utils",
"combine",
"all",
"(",
"execution",
"graph",
"futures",
")",
";",
"collection",
"<",
"access",
"execution",
"graph",
">",
"all",
"execution",
"graphs",
"=",
"all",
"execution",
"graph",
"futures",
"get",
"(",
")",
";",
"for",
"(",
"access",
"execution",
"graph",
"execution",
"graph",
":",
"all",
"execution",
"graphs",
")",
"{",
"assert",
"equals",
"(",
"expected",
"execution",
"graph",
",",
"execution",
"graph",
")",
";",
"}",
"assert",
"that",
"(",
"restful",
"gateway",
"get",
"num",
"request",
"job",
"calls",
"(",
")",
",",
"matchers",
"equal",
"to",
"(",
"1",
")",
")",
";",
"}",
"finally",
"{",
"executor",
"utils",
"graceful",
"shutdown",
"(",
"5000l",
",",
"time",
"unit",
"milliseconds",
",",
"executor",
")",
";",
"}",
"}"
] |
[
"assert",
"a",
"boolean",
"expression",
",",
"throwing",
"an",
"{",
"@",
"code",
"illegal",
"state",
"exception",
"}",
"if",
"the",
"expression",
"evaluates",
"to",
"{",
"@",
"code",
"false",
"}",
"call",
"{",
"@",
"link",
"#",
"is",
"true",
"}",
"if",
"you",
"wish",
"to",
"throw",
"an",
"{",
"@",
"code",
"illegal",
"argument",
"exception",
"}",
"on",
"an",
"assertion",
"failure",
"<",
"pre",
"class",
"=",
"\"",
"code",
"\"",
">",
"assert",
"state",
"(",
"entity",
"get",
"id",
"(",
")",
"=",
"=",
"null",
",",
"(",
")",
"-",
"&",
"gt",
";",
"\"",
"id",
"for",
"entity",
"\"",
"+",
"entity",
"get",
"name",
"(",
")",
"+",
"\"",
"must",
"not",
"already",
"be",
"initialized",
"\"",
")",
";"
] |
[
"public",
"static",
"void",
"state",
"(",
"boolean",
"expression",
",",
"supplier",
"<",
"string",
">",
"message",
"supplier",
")",
"{",
"if",
"(",
"!",
"expression",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"null",
"safe",
"get",
"(",
"message",
"supplier",
")",
")",
";",
"}",
"}"
] |
[
"test",
"start",
"form",
"console",
"command",
"without",
"options"
] |
[
"private",
"void",
"start",
"stop",
"(",
")",
"{",
"byte",
"array",
"output",
"stream",
"data",
"=",
"new",
"byte",
"array",
"output",
"stream",
"(",
")",
";",
"print",
"stream",
"error",
"=",
"system",
"err",
";",
"system",
"set",
"err",
"(",
"new",
"print",
"stream",
"(",
"data",
")",
")",
";",
"exit",
"util",
"disable",
"system",
"exit",
"(",
")",
";",
"try",
"{",
"cli",
"main",
"(",
"new",
"string",
"[",
"0",
"]",
")",
";",
"fail",
"(",
"\"",
"cli",
"main",
"should",
"call",
"system",
"exit",
"\"",
")",
";",
"}",
"catch",
"(",
"exit",
"util",
"exit",
"exception",
"e",
")",
"{",
"exit",
"util",
"reset",
"first",
"exit",
"exception",
"(",
")",
";",
"assert",
"equals",
"(",
"-",
"1",
",",
"e",
"status",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"}",
"finally",
"{",
"system",
"set",
"err",
"(",
"error",
")",
";",
"}",
"/",
"/",
"in",
"console",
"should",
"be",
"written",
"help",
"text",
"string",
"s",
"=",
"new",
"string",
"(",
"data",
"to",
"byte",
"array",
"(",
")",
")",
";",
"assert",
"true",
"(",
"s",
"contains",
"(",
"\"",
"-",
"submit",
"\"",
")",
")",
";",
"assert",
"true",
"(",
"s",
"contains",
"(",
"\"",
"-",
"status",
"\"",
")",
")",
";",
"assert",
"true",
"(",
"s",
"contains",
"(",
"\"",
"-",
"kill",
"\"",
")",
")",
";",
"assert",
"true",
"(",
"s",
"contains",
"(",
"\"",
"-",
"set",
"-",
"priority",
"\"",
")",
")",
";",
"assert",
"true",
"(",
"s",
"contains",
"(",
"\"",
"-",
"events",
"\"",
")",
")",
";",
"assert",
"true",
"(",
"s",
"contains",
"(",
"\"",
"-",
"history",
"\"",
")",
")",
";",
"assert",
"true",
"(",
"s",
"contains",
"(",
"\"",
"-",
"list",
"\"",
")",
")",
";",
"assert",
"true",
"(",
"s",
"contains",
"(",
"\"",
"-",
"list",
"-",
"active",
"-",
"trackers",
"\"",
")",
")",
";",
"assert",
"true",
"(",
"s",
"contains",
"(",
"\"",
"-",
"list",
"-",
"blacklisted",
"-",
"trackers",
"\"",
")",
")",
";",
"assert",
"true",
"(",
"s",
"contains",
"(",
"\"",
"-",
"list",
"-",
"attempt",
"-",
"ids",
"\"",
")",
")",
";",
"assert",
"true",
"(",
"s",
"contains",
"(",
"\"",
"-",
"kill",
"-",
"task",
"\"",
")",
")",
";",
"assert",
"true",
"(",
"s",
"contains",
"(",
"\"",
"-",
"fail",
"-",
"task",
"\"",
")",
")",
";",
"assert",
"true",
"(",
"s",
"contains",
"(",
"\"",
"-",
"logs",
"\"",
")",
")",
";",
"}"
] |
[
"update",
"property",
"for",
"map",
"container"
] |
[
"protected",
"void",
"update",
"property",
"for",
"map",
"(",
"codegen",
"property",
"property",
",",
"codegen",
"property",
"inner",
"property",
")",
"{",
"if",
"(",
"inner",
"property",
"=",
"=",
"null",
")",
"{",
"logger",
"warn",
"(",
"\"",
"skipping",
"invalid",
"map",
"property",
"\"",
"+",
"json",
"pretty",
"(",
"property",
")",
")",
";",
"return",
";",
"}",
"if",
"(",
"!",
"language",
"specific",
"primitives",
"contains",
"(",
"inner",
"property",
"base",
"type",
")",
")",
"{",
"property",
"complex",
"type",
"=",
"inner",
"property",
"base",
"type",
";",
"}",
"else",
"{",
"property",
"is",
"primitive",
"type",
"=",
"true",
";",
"}",
"property",
"items",
"=",
"inner",
"property",
";",
"property",
"most",
"inner",
"items",
"=",
"get",
"most",
"inner",
"items",
"(",
"inner",
"property",
")",
";",
"property",
"data",
"format",
"=",
"inner",
"property",
"data",
"format",
";",
"/",
"/",
"inner",
"item",
"is",
"enum",
"if",
"(",
"is",
"property",
"inner",
"most",
"enum",
"(",
"property",
")",
")",
"{",
"/",
"/",
"is",
"enum",
"is",
"set",
"to",
"true",
"when",
"the",
"type",
"is",
"an",
"enum",
"/",
"/",
"or",
"the",
"inner",
"type",
"of",
"an",
"array",
"/",
"map",
"is",
"an",
"enum",
"property",
"is",
"enum",
"=",
"true",
";",
"/",
"/",
"update",
"datatype",
"with",
"enum",
"and",
"default",
"value",
"for",
"map",
"/",
"/",
"e",
"g",
"dictionary",
"<",
"string",
",",
"string",
">",
"=",
">",
"dictionary",
"<",
"string",
",",
"status",
"enum",
">",
"update",
"data",
"type",
"with",
"enum",
"for",
"map",
"(",
"property",
")",
";",
"/",
"/",
"set",
"allowable",
"values",
"to",
"enum",
"values",
"(",
"including",
"array",
"/",
"map",
"of",
"enum",
")",
"property",
"allowable",
"values",
"=",
"get",
"inner",
"enum",
"allowable",
"values",
"(",
"property",
")",
";",
"}",
"}"
] |
[
"parses",
"and",
"validates",
"the",
"service",
"configuration",
"chosen",
"by",
"the",
"name",
"resolver",
"this",
"will",
"return",
"a",
"{",
"@",
"link",
"config",
"or",
"error",
"}",
"which",
"contains",
"either",
"the",
"successfully",
"parsed",
"config",
",",
"or",
"the",
"{",
"@",
"link",
"status",
"}",
"representing",
"the",
"failure",
"to",
"parse",
"implementations",
"are",
"expected",
"to",
"not",
"throw",
"exceptions",
"but",
"return",
"a",
"status",
"representing",
"the",
"failure",
"the",
"value",
"inside",
"the",
"{",
"@",
"link",
"config",
"or",
"error",
"}",
"should",
"implement",
"{",
"@",
"code",
"equals",
"(",
")",
"}",
"and",
"{",
"@",
"code",
"hash",
"code",
"(",
")",
"}"
] |
[
"public",
"config",
"or",
"error",
"parse",
"service",
"config",
"(",
"map",
"<",
"string",
",",
"?",
">",
"raw",
"service",
"config",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
"\"",
"should",
"have",
"been",
"implemented",
"\"",
")",
";",
"}"
] |
[
"returns",
"true",
"if",
"this",
"filter",
"is",
"a",
"more",
"specific",
"filter",
"of",
"the",
"given",
"filter",
"this",
"is",
"specific",
"to",
"the",
"implementation",
"some",
"filters",
"cannot",
"be",
"sub",
"-",
"filters",
"of",
"another",
"filter",
",",
"such",
"as",
"the",
"'",
"matches",
"exactly",
"'",
"filter",
"contrastingly",
",",
"a",
"'",
"starts",
"with",
"'",
"filter",
"can",
"have",
"a",
"sub",
"-",
"filter",
";",
"for",
"example",
",",
"for",
"a",
"'",
"starts",
"with",
"'",
"filter",
",",
"'",
"cat",
"'",
"is",
"a",
"sub",
"-",
"filter",
"of",
"'",
"ca",
"'",
",",
"as",
"'",
"cat",
"'",
"starts",
"with",
"'",
"ca",
"'"
] |
[
"public",
"boolean",
"is",
"sub",
"filter",
"of",
"(",
"text",
"filter",
"filter",
")",
";"
] |
[
"adds",
"the",
"caller",
"to",
"a",
"list",
"of",
"subscribers",
"who",
"will",
"be",
"notified",
"when",
"selection",
"changes"
] |
[
"public",
"void",
"add",
"drop",
"down",
"selection",
"choice",
"listener",
"(",
"drop",
"down",
"multi",
"selection",
"choice",
"listener",
"<",
"t",
">",
"listener",
")",
"{",
"choice",
"listeners",
"add",
"(",
"listener",
")",
";",
"}"
] |
[
"converts",
"an",
"integer",
"into",
"a",
"string",
"for",
"example",
",",
"given",
"an",
"integer",
"0x",
"4",
"1",
"4",
"2",
"4",
"3",
"4",
"4",
",",
"the",
"returned",
"string",
"would",
"be",
"\"",
"abcd",
"\""
] |
[
"public",
"static",
"string",
"to",
"string",
"(",
"int",
"value",
")",
"{",
"byte",
"[",
"]",
"bytes",
"=",
"new",
"byte",
"[",
"4",
"]",
";",
"int",
"byte",
"index",
"=",
"bytes",
"length",
"-",
"1",
";",
"while",
"(",
"value",
"!",
"=",
"0",
")",
"{",
"bytes",
"[",
"byte",
"index",
"]",
"=",
"(",
"byte",
")",
"value",
";",
"value",
"=",
"value",
">",
">",
"8",
";",
"-",
"-",
"byte",
"index",
";",
"}",
"return",
"new",
"string",
"(",
"bytes",
")",
";",
"}"
] |
[
"return",
"true",
"if",
"this",
"instance",
"has",
"a",
"defined",
"port"
] |
[
"public",
"boolean",
"has",
"port",
"(",
")",
"{",
"return",
"port",
">",
"=",
"0",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"attribute",
"number",
"'"
] |
[
"public",
"void",
"attribute",
"number",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"attribute",
"number",
"}"
] |
[
"set",
"a",
"single",
"basename",
",",
"following",
"the",
"basic",
"resource",
"bundle",
"convention",
"of",
"not",
"specifying",
"file",
"extension",
"or",
"language",
"codes",
"the",
"resource",
"location",
"format",
"is",
"up",
"to",
"the",
"specific",
"{",
"@",
"code",
"message",
"source",
"}",
"implementation",
"regular",
"and",
"x",
"ml",
"properties",
"files",
"are",
"supported",
":",
"e",
"g",
"\"",
"messages",
"\"",
"will",
"find",
"a",
"\"",
"messages",
"properties",
"\"",
",",
"\"",
"messages",
"en",
"properties",
"\"",
"etc",
"arrangement",
"as",
"well",
"as",
"\"",
"messages",
"xml",
"\"",
",",
"\"",
"messages",
"en",
"xml",
"\"",
"etc"
] |
[
"public",
"void",
"set",
"basename",
"(",
"string",
"basename",
")",
"{",
"set",
"basenames",
"(",
"basename",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"name",
"'"
] |
[
"public",
"void",
"name",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"name",
"}"
] |
[
"tests",
"to",
"verify",
"that",
"the",
"buffer",
"pool",
"will",
"distribute",
"available",
"floating",
"buffers",
"among",
"all",
"the",
"channel",
"listeners",
"in",
"a",
"fair",
"way"
] |
[
"public",
"void",
"test",
"fair",
"distribution",
"floating",
"buffers",
"(",
")",
"throws",
"exception",
"{",
"/",
"/",
"setup",
"final",
"int",
"num",
"exclusive",
"buffers",
"=",
"2",
";",
"final",
"network",
"buffer",
"pool",
"network",
"buffer",
"pool",
"=",
"new",
"network",
"buffer",
"pool",
"(",
"12",
",",
"32",
")",
";",
"final",
"int",
"num",
"floating",
"buffers",
"=",
"3",
";",
"final",
"single",
"input",
"gate",
"input",
"gate",
"=",
"create",
"single",
"input",
"gate",
"(",
"3",
",",
"network",
"buffer",
"pool",
")",
";",
"final",
"remote",
"input",
"channel",
"[",
"]",
"input",
"channels",
"=",
"new",
"remote",
"input",
"channel",
"[",
"3",
"]",
";",
"input",
"channels",
"[",
"0",
"]",
"=",
"create",
"remote",
"input",
"channel",
"(",
"input",
"gate",
")",
";",
"input",
"channels",
"[",
"1",
"]",
"=",
"create",
"remote",
"input",
"channel",
"(",
"input",
"gate",
")",
";",
"input",
"channels",
"[",
"2",
"]",
"=",
"create",
"remote",
"input",
"channel",
"(",
"input",
"gate",
")",
";",
"input",
"gate",
"set",
"input",
"channels",
"(",
"input",
"channels",
")",
";",
"throwable",
"thrown",
"=",
"null",
";",
"try",
"{",
"final",
"buffer",
"pool",
"buffer",
"pool",
"=",
"spy",
"(",
"network",
"buffer",
"pool",
"create",
"buffer",
"pool",
"(",
"num",
"floating",
"buffers",
",",
"num",
"floating",
"buffers",
")",
")",
";",
"input",
"gate",
"set",
"buffer",
"pool",
"(",
"buffer",
"pool",
")",
";",
"input",
"gate",
"setup",
"channels",
"(",
")",
";",
"input",
"gate",
"request",
"partitions",
"(",
")",
";",
"for",
"(",
"remote",
"input",
"channel",
"input",
"channel",
":",
"input",
"channels",
")",
"{",
"input",
"channel",
"request",
"subpartition",
"(",
"0",
")",
";",
"}",
"/",
"/",
"exhaust",
"all",
"the",
"floating",
"buffers",
"final",
"list",
"<",
"buffer",
">",
"floating",
"buffers",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"num",
"floating",
"buffers",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"num",
"floating",
"buffers",
";",
"i",
"+",
"+",
")",
"{",
"buffer",
"buffer",
"=",
"buffer",
"pool",
"request",
"buffer",
"(",
")",
";",
"assert",
"not",
"null",
"(",
"buffer",
")",
";",
"floating",
"buffers",
"add",
"(",
"buffer",
")",
";",
"}",
"/",
"/",
"receive",
"the",
"producer",
"'",
"s",
"backlog",
"to",
"trigger",
"request",
"floating",
"buffers",
"from",
"pool",
"/",
"/",
"and",
"register",
"as",
"listeners",
"as",
"a",
"result",
"for",
"(",
"remote",
"input",
"channel",
"input",
"channel",
":",
"input",
"channels",
")",
"{",
"input",
"channel",
"on",
"sender",
"backlog",
"(",
"8",
")",
";",
"verify",
"(",
"buffer",
"pool",
",",
"times",
"(",
"1",
")",
")",
"add",
"buffer",
"listener",
"(",
"input",
"channel",
"get",
"buffer",
"manager",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"there",
"should",
"be",
"\"",
"+",
"num",
"exclusive",
"buffers",
"+",
"\"",
"buffers",
"available",
"in",
"the",
"channel",
"\"",
",",
"num",
"exclusive",
"buffers",
",",
"input",
"channel",
"get",
"number",
"of",
"available",
"buffers",
"(",
")",
")",
";",
"}",
"/",
"/",
"recycle",
"three",
"floating",
"buffers",
"to",
"trigger",
"notify",
"buffer",
"available",
"for",
"(",
"buffer",
"buffer",
":",
"floating",
"buffers",
")",
"{",
"buffer",
"recycle",
"buffer",
"(",
")",
";",
"}",
"for",
"(",
"remote",
"input",
"channel",
"input",
"channel",
":",
"input",
"channels",
")",
"{",
"assert",
"equals",
"(",
"\"",
"there",
"should",
"be",
"3",
"buffers",
"available",
"in",
"the",
"channel",
"\"",
",",
"3",
",",
"input",
"channel",
"get",
"number",
"of",
"available",
"buffers",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"there",
"should",
"be",
"1",
"unannounced",
"credits",
"in",
"the",
"channel",
"\"",
",",
"1",
",",
"input",
"channel",
"get",
"unannounced",
"credit",
"(",
")",
")",
";",
"}",
"}",
"catch",
"(",
"throwable",
"t",
")",
"{",
"thrown",
"=",
"t",
";",
"}",
"finally",
"{",
"cleanup",
"(",
"network",
"buffer",
"pool",
",",
"null",
",",
"null",
",",
"thrown",
",",
"input",
"channels",
")",
";",
"}",
"}"
] |
[
"asserts",
"the",
"request",
"was",
"forwarded",
"to",
"the",
"given",
"url",
"this",
"method",
"accepts",
"{",
"@",
"link",
"org",
"springframework",
"util",
"ant",
"path",
"matcher",
"}",
"patterns"
] |
[
"public",
"static",
"result",
"matcher",
"forwarded",
"url",
"pattern",
"(",
"string",
"url",
"pattern",
")",
"{",
"return",
"result",
"-",
">",
"{",
"assert",
"true",
"(",
"\"",
"'",
"\"",
"+",
"url",
"pattern",
"+",
"\"",
"'",
"is",
"not",
"an",
"ant",
"-",
"style",
"path",
"pattern",
"\"",
",",
"path",
"matcher",
"is",
"pattern",
"(",
"url",
"pattern",
")",
")",
";",
"string",
"url",
"=",
"result",
"get",
"response",
"(",
")",
"get",
"forwarded",
"url",
"(",
")",
";",
"assert",
"true",
"(",
"\"",
"forwarded",
"url",
"'",
"\"",
"+",
"url",
"+",
"\"",
"'",
"does",
"not",
"match",
"the",
"expected",
"url",
"pattern",
"'",
"\"",
"+",
"url",
"pattern",
"+",
"\"",
"'",
"\"",
",",
"(",
"url",
"!",
"=",
"null",
"&",
"&",
"path",
"matcher",
"match",
"(",
"url",
"pattern",
",",
"url",
")",
")",
")",
";",
"}",
";",
"}"
] |
[
"tests",
"{",
"@",
"code",
"equals",
"(",
")",
"}",
"and",
"{",
"@",
"code",
"hash",
"code",
"(",
")",
"}",
"implementations",
"for",
"every",
"top",
"-",
"level",
"class",
"in",
"the",
"package",
",",
"that",
"explicitly",
"implements",
"{",
"@",
"link",
"object",
"#",
"equals",
"}",
"for",
"a",
"class",
"{",
"@",
"code",
"c",
"}",
":",
"the",
"visible",
"constructor",
"or",
"visible",
"static",
"factory",
"method",
"with",
"the",
"most",
"parameters",
"is",
"used",
"to",
"construct",
"the",
"sample",
"instances",
"in",
"case",
"of",
"tie",
",",
"the",
"candidate",
"constructors",
"or",
"factories",
"are",
"tried",
"one",
"after",
"another",
"until",
"one",
"can",
"be",
"used",
"to",
"construct",
"sample",
"instances",
"for",
"the",
"constructor",
"or",
"static",
"factory",
"method",
"used",
"to",
"construct",
"instances",
",",
"it",
"'",
"s",
"checked",
"that",
"when",
"equal",
"parameters",
"are",
"passed",
",",
"the",
"result",
"instance",
"should",
"also",
"be",
"equal",
";",
"and",
"vice",
"versa",
"inequality",
"check",
"is",
"not",
"performed",
"against",
"state",
"mutation",
"methods",
"such",
"as",
"{",
"@",
"link",
"list",
"#",
"add",
"}",
",",
"or",
"functional",
"update",
"methods",
"such",
"as",
"{",
"@",
"link",
"com",
"google",
"common",
"base",
"joiner",
"#",
"skip",
"nulls",
"}",
"if",
"the",
"constructor",
"or",
"factory",
"method",
"used",
"to",
"construct",
"instance",
"takes",
"a",
"parameter",
"that",
"{",
"@",
"link",
"abstract",
"package",
"sanity",
"tests",
"}",
"doesn",
"'",
"t",
"know",
"how",
"to",
"construct",
",",
"the",
"test",
"will",
"fail",
"if",
"there",
"is",
"no",
"visible",
"constructor",
"or",
"visible",
"static",
"factory",
"method",
"declared",
"by",
"{",
"@",
"code",
"c",
"}",
",",
"{",
"@",
"code",
"c",
"}",
"is",
"skipped",
"for",
"equality",
"test",
"equality",
"test",
"is",
"not",
"performed",
"on",
"method",
"return",
"values",
"unless",
"the",
"method",
"is",
"a",
"visible",
"static",
"factory",
"method",
"whose",
"return",
"type",
"is",
"{",
"@",
"code",
"c",
"}",
"or",
"{",
"@",
"code",
"c",
"}",
"'",
"s",
"subtype",
"in",
"all",
"cases",
",",
"if",
"{",
"@",
"code",
"c",
"}",
"needs",
"custom",
"logic",
"for",
"testing",
"{",
"@",
"code",
"equals",
"(",
")",
"}",
",",
"you",
"can",
"add",
"an",
"explicit",
"{",
"@",
"code",
"test",
"equals",
"(",
")",
"}",
"test",
"in",
"the",
"corresponding",
"{",
"@",
"code",
"c",
"test",
"}",
"class",
",",
"and",
"{",
"@",
"code",
"c",
"}",
"will",
"be",
"excluded",
"from",
"the",
"automated",
"{",
"@",
"code",
"equals",
"}",
"test",
"performed",
"by",
"this",
"method"
] |
[
"public",
"void",
"test",
"equals",
"(",
")",
"throws",
"exception",
"{",
"for",
"(",
"class",
"<",
"?",
">",
"class",
"to",
"test",
":",
"find",
"classes",
"to",
"test",
"(",
"load",
"classes",
"in",
"package",
"(",
")",
",",
"equals",
"test",
"method",
"names",
")",
")",
"{",
"if",
"(",
"!",
"class",
"to",
"test",
"is",
"enum",
"(",
")",
"&",
"&",
"is",
"equals",
"defined",
"(",
"class",
"to",
"test",
")",
")",
"{",
"try",
"{",
"tester",
"do",
"test",
"equals",
"(",
"class",
"to",
"test",
")",
";",
"}",
"catch",
"(",
"throwable",
"e",
")",
"{",
"throw",
"sanity",
"error",
"(",
"class",
"to",
"test",
",",
"equals",
"test",
"method",
"names",
",",
"\"",
"equals",
"test",
"\"",
",",
"e",
")",
";",
"}",
"}",
"}",
"}"
] |
[
"like",
"{",
"@",
"link",
"#",
"is",
"message",
"request",
"accepted",
"(",
"context",
",",
"long",
")",
"}",
"but",
"with",
"fewer",
"checks",
"around",
"messages",
"so",
"it",
"is",
"more",
"likely",
"to",
"return",
"false"
] |
[
"public",
"static",
"boolean",
"is",
"call",
"request",
"accepted",
"(",
"@",
"non",
"null",
"context",
"context",
",",
"@",
"nullable",
"recipient",
"thread",
"recipient",
")",
"{",
"if",
"(",
"thread",
"recipient",
"=",
"=",
"null",
")",
"{",
"return",
"true",
";",
"}",
"long",
"thread",
"id",
"=",
"database",
"factory",
"get",
"thread",
"database",
"(",
"context",
")",
"get",
"thread",
"id",
"for",
"(",
"thread",
"recipient",
")",
";",
"return",
"is",
"call",
"request",
"accepted",
"(",
"context",
",",
"thread",
"id",
",",
"thread",
"recipient",
")",
";",
"}"
] |
[
"generate",
"a",
"concrete",
"pointer",
"varnode",
"for",
"a",
"dynamic",
"varnode",
"template"
] |
[
"private",
"address",
"space",
"generate",
"pointer",
"(",
"varnode",
"tpl",
"vntpl",
",",
"varnode",
"data",
"vn",
")",
"{",
"fixed",
"handle",
"hand",
"=",
"walker",
"get",
"fixed",
"handle",
"(",
"vntpl",
"get",
"offset",
"(",
")",
"get",
"handle",
"index",
"(",
")",
")",
";",
"vn",
"space",
"=",
"hand",
"offset",
"space",
";",
"vn",
"size",
"=",
"hand",
"offset",
"size",
";",
"if",
"(",
"vn",
"space",
"=",
"=",
"const",
"space",
")",
"{",
"vn",
"offset",
"=",
"hand",
"offset",
"offset",
"&",
"const",
"tpl",
"calc",
"mask",
"[",
"vn",
"size",
"]",
";",
"}",
"else",
"if",
"(",
"vn",
"space",
"=",
"=",
"uniq",
"space",
")",
"{",
"vn",
"offset",
"=",
"hand",
"offset",
"offset",
"|",
"uniqueoffset",
";",
"}",
"else",
"{",
"vn",
"offset",
"=",
"vn",
"space",
"truncate",
"offset",
"(",
"hand",
"offset",
"offset",
")",
";",
"}",
"return",
"hand",
"space",
";",
"}"
] |
[
"ensures",
"that",
"an",
"object",
"reference",
"passed",
"as",
"a",
"parameter",
"to",
"the",
"calling",
"method",
"is",
"not",
"null",
"see",
"{",
"@",
"link",
"#",
"check",
"not",
"null",
"(",
"object",
",",
"string",
",",
"object",
")",
"}",
"for",
"details"
] |
[
"public",
"static",
"<",
"t",
"extends",
"object",
">",
"t",
"check",
"not",
"null",
"(",
"@",
"non",
"null",
"decl",
"t",
"obj",
",",
"@",
"nullable",
"decl",
"string",
"error",
"message",
"template",
",",
"@",
"nullable",
"decl",
"object",
"p",
"1",
")",
"{",
"if",
"(",
"obj",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"null",
"pointer",
"exception",
"(",
"lenient",
"format",
"(",
"error",
"message",
"template",
",",
"p",
"1",
")",
")",
";",
"}",
"return",
"obj",
";",
"}"
] |
[
"tries",
"to",
"unwrap",
"the",
"given",
"reader",
"until",
"the",
"first",
"{",
"@",
"link",
"elasticsearch",
"directory",
"reader",
"}",
"instance",
"is",
"found",
"or",
"{",
"@",
"code",
"null",
"}",
"if",
"no",
"instance",
"is",
"found"
] |
[
"public",
"static",
"elasticsearch",
"directory",
"reader",
"get",
"elasticsearch",
"directory",
"reader",
"(",
"directory",
"reader",
"reader",
")",
"{",
"if",
"(",
"reader",
"instanceof",
"filter",
"directory",
"reader",
")",
"{",
"if",
"(",
"reader",
"instanceof",
"elasticsearch",
"directory",
"reader",
")",
"{",
"return",
"(",
"elasticsearch",
"directory",
"reader",
")",
"reader",
";",
"}",
"else",
"{",
"/",
"/",
"we",
"need",
"to",
"use",
"filter",
"directory",
"reader",
"#",
"get",
"delegate",
"and",
"not",
"filter",
"directory",
"reader",
"#",
"unwrap",
",",
"because",
"/",
"/",
"if",
"there",
"are",
"multiple",
"levels",
"of",
"filtered",
"leaf",
"readers",
"then",
"with",
"the",
"unwrap",
"(",
")",
"method",
"it",
"immediately",
"/",
"/",
"returns",
"the",
"most",
"inner",
"leaf",
"reader",
"and",
"thus",
"skipping",
"of",
"over",
"any",
"other",
"filtered",
"leaf",
"reader",
"that",
"/",
"/",
"may",
"be",
"instance",
"of",
"elasticsearch",
"leaf",
"reader",
"this",
"can",
"cause",
"us",
"to",
"miss",
"the",
"shard",
"id",
"return",
"get",
"elasticsearch",
"directory",
"reader",
"(",
"(",
"(",
"filter",
"directory",
"reader",
")",
"reader",
")",
"get",
"delegate",
"(",
")",
")",
";",
"}",
"}",
"return",
"null",
";",
"}"
] |
[
"test",
"that",
"program",
"diff",
"can",
"determine",
"the",
"code",
"unit",
"differences",
"between",
"program",
"1",
"and",
"program",
"2",
"when",
"the",
"bytes",
"differ",
"for",
"an",
"instruction",
"but",
"its",
"prototype",
"doesn",
"'",
"t"
] |
[
"public",
"void",
"test",
"get",
"code",
"unit",
"differences",
"same",
"prototype",
"diff",
"byte",
"(",
")",
"throws",
"exception",
"{",
"program",
"builder",
"1",
"clear",
"code",
"units",
"(",
"\"",
"0x",
"0",
"1",
"0",
"0",
"2cf",
"8",
"\"",
",",
"\"",
"0x",
"0",
"1",
"0",
"0",
"2cfb",
"\"",
",",
"false",
")",
";",
"program",
"builder",
"1",
"set",
"bytes",
"(",
"\"",
"0x",
"0",
"1",
"0",
"0",
"2cf",
"8",
"\"",
",",
"\"",
"3b",
"74",
"24",
"08",
"\"",
",",
"true",
")",
";",
"program",
"builder",
"2",
"clear",
"code",
"units",
"(",
"\"",
"0x",
"0",
"1",
"0",
"0",
"2cf",
"8",
"\"",
",",
"\"",
"0x",
"0",
"1",
"0",
"0",
"2cfb",
"\"",
",",
"false",
")",
";",
"program",
"builder",
"2",
"set",
"bytes",
"(",
"\"",
"0x",
"0",
"1",
"0",
"0",
"2cf",
"8",
"\"",
",",
"\"",
"3b",
"74",
"24",
"0c",
"\"",
",",
"true",
")",
";",
"/",
"/",
"p",
"1",
"&",
"p",
"2",
"differ",
"at",
"byte",
"at",
"0x",
"0",
"1",
"0",
"0",
"2cfb",
"program",
"diff",
"=",
"new",
"program",
"diff",
"(",
"p",
"1",
",",
"p",
"2",
")",
";",
"program",
"diff",
"set",
"filter",
"(",
"new",
"program",
"diff",
"filter",
"(",
"program",
"diff",
"filter",
"code",
"unit",
"diffs",
")",
")",
";",
"address",
"set",
"as",
"=",
"new",
"address",
"set",
"(",
")",
";",
"as",
"add",
"range",
"(",
"addr",
"(",
"p",
"1",
",",
"0x",
"0",
"1",
"0",
"0",
"2cf",
"8",
")",
",",
"addr",
"(",
"p",
"1",
",",
"0x",
"0",
"1",
"0",
"0",
"2cfb",
")",
")",
";",
"check",
"address",
"set",
"(",
"as",
",",
"program",
"diff",
"get",
"differences",
"(",
"program",
"diff",
"get",
"filter",
"(",
")",
",",
"null",
")",
")",
";",
"}"
] |
[
"create",
"a",
"symlink",
"pointing",
"to",
"the",
"destination",
"path"
] |
[
"public",
"void",
"create",
"symlink",
"(",
"path",
"destination",
",",
"path",
"f",
",",
"boolean",
"create",
"parent",
")",
"throws",
"i",
"o",
"exception",
"{",
"statistics",
"increment",
"write",
"ops",
"(",
"1",
")",
";",
"storage",
"statistics",
"increment",
"op",
"counter",
"(",
"op",
"type",
"create",
"sym",
"link",
")",
";",
"final",
"http",
"op",
"param",
"op",
"op",
"=",
"put",
"op",
"param",
"op",
"createsymlink",
";",
"new",
"fs",
"path",
"runner",
"(",
"op",
",",
"f",
",",
"new",
"destination",
"param",
"(",
"make",
"qualified",
"(",
"destination",
")",
"to",
"uri",
"(",
")",
"get",
"path",
"(",
")",
")",
",",
"new",
"create",
"parent",
"param",
"(",
"create",
"parent",
")",
")",
"run",
"(",
")",
";",
"}"
] |
[
"initialize",
"the",
"given",
"client",
"http",
"request"
] |
[
"void",
"initialize",
"(",
"client",
"http",
"request",
"request",
")",
";"
] |
[
"start",
"counting",
",",
"call",
"this",
"method",
"just",
"before",
"performing",
"the",
"task",
"you",
"want",
"to",
"keep",
"track",
"of",
"call",
"{",
"@",
"link",
"#",
"stop",
"(",
")",
"}",
"when",
"done"
] |
[
"public",
"void",
"start",
"(",
")",
"{",
"start",
"time",
"=",
"time",
"utils",
"nano",
"time",
"(",
")",
";",
"valid",
"=",
"false",
";",
"}"
] |
[
"execute",
"an",
"on",
"-",
"demand",
"cleaner",
"task"
] |
[
"protected",
"void",
"run",
"cleaner",
"task",
"(",
")",
"{",
"runnable",
"task",
"=",
"cleaner",
"task",
"create",
"(",
"conf",
",",
"store",
",",
"metrics",
",",
"cleaner",
"task",
"lock",
")",
";",
"/",
"/",
"this",
"is",
"a",
"non",
"-",
"blocking",
"call",
"(",
"it",
"simply",
"submits",
"the",
"task",
"to",
"the",
"executor",
"/",
"/",
"queue",
"and",
"returns",
")",
"this",
"scheduled",
"executor",
"execute",
"(",
"task",
")",
";",
"}"
] |
[
"{",
"@",
"code",
"mockito",
"session",
"}",
"is",
"an",
"optional",
",",
"highly",
"recommended",
"feature",
"that",
"helps",
"driving",
"cleaner",
"tests",
"by",
"eliminating",
"boilerplate",
"code",
"and",
"adding",
"extra",
"validation",
"for",
"more",
"information",
",",
"including",
"use",
"cases",
"and",
"sample",
"code",
",",
"see",
"the",
"javadoc",
"for",
"{",
"@",
"link",
"mockito",
"session",
"}"
] |
[
"public",
"static",
"mockito",
"session",
"builder",
"mockito",
"session",
"(",
")",
"{",
"return",
"new",
"default",
"mockito",
"session",
"builder",
"(",
")",
";",
"}"
] |
[
"gets",
"a",
"new",
"{",
"@",
"link",
"snapshot",
"info",
"}",
"instance",
"from",
"the",
"given",
"{",
"@",
"link",
"snapshot",
"info",
"}",
"with",
"all",
"information",
"stripped",
"out",
"except",
"the",
"snapshot",
"id",
",",
"state",
",",
"and",
"indices"
] |
[
"public",
"snapshot",
"info",
"basic",
"(",
")",
"{",
"return",
"new",
"snapshot",
"info",
"(",
"snapshot",
"id",
",",
"indices",
",",
"collections",
"empty",
"list",
"(",
")",
",",
"state",
")",
";",
"}"
] |
[
"checks",
"whether",
"to",
"invoke",
"finish",
"bundle",
"by",
"elements",
"count",
"called",
"in",
"process",
"element"
] |
[
"protected",
"void",
"check",
"invoke",
"finish",
"bundle",
"by",
"count",
"(",
")",
"throws",
"exception",
"{",
"if",
"(",
"element",
"count",
">",
"=",
"max",
"bundle",
"size",
")",
"{",
"invoke",
"finish",
"bundle",
"(",
")",
";",
"}",
"}"
] |
[
"replaces",
"control",
"characters",
"by",
"their",
"escape",
"-",
"coded",
"version",
"for",
"example",
",",
"if",
"the",
"string",
"contains",
"a",
"line",
"break",
"character",
"(",
"'",
"\\",
"n",
"'",
")",
",",
"this",
"character",
"will",
"be",
"replaced",
"by",
"the",
"two",
"characters",
"backslash",
"'",
"\\",
"'",
"and",
"'",
"n",
"'",
"as",
"a",
"consequence",
",",
"the",
"resulting",
"string",
"will",
"not",
"contain",
"any",
"more",
"control",
"characters"
] |
[
"public",
"static",
"string",
"show",
"control",
"characters",
"(",
"string",
"str",
")",
"{",
"int",
"len",
"=",
"str",
"length",
"(",
")",
";",
"string",
"builder",
"sb",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"len",
";",
"i",
"+",
"=",
"1",
")",
"{",
"char",
"c",
"=",
"str",
"char",
"at",
"(",
"i",
")",
";",
"switch",
"(",
"c",
")",
"{",
"case",
"'",
"\\",
"b",
"'",
":",
"sb",
"append",
"(",
"\"",
"\\",
"\\",
"b",
"\"",
")",
";",
"break",
";",
"case",
"'",
"\\",
"t",
"'",
":",
"sb",
"append",
"(",
"\"",
"\\",
"\\",
"t",
"\"",
")",
";",
"break",
";",
"case",
"'",
"\\",
"n",
"'",
":",
"sb",
"append",
"(",
"\"",
"\\",
"\\",
"n",
"\"",
")",
";",
"break",
";",
"case",
"'",
"\\",
"f",
"'",
":",
"sb",
"append",
"(",
"\"",
"\\",
"\\",
"f",
"\"",
")",
";",
"break",
";",
"case",
"'",
"\\",
"r",
"'",
":",
"sb",
"append",
"(",
"\"",
"\\",
"\\",
"r",
"\"",
")",
";",
"break",
";",
"default",
":",
"sb",
"append",
"(",
"c",
")",
";",
"}",
"}",
"return",
"sb",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"delete",
"pet",
"{",
"pet",
"id",
"}",
":",
"deletes",
"a",
"pet"
] |
[
"default",
"response",
"entity",
"<",
"void",
">",
"delete",
"pet",
"(",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"pet",
"id",
"to",
"delete",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"path",
"variable",
"(",
"\"",
"pet",
"id",
"\"",
")",
"long",
"pet",
"id",
",",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"\"",
")",
"@",
"request",
"header",
"(",
"value",
"=",
"\"",
"api",
"key",
"\"",
",",
"required",
"=",
"false",
")",
"string",
"api",
"key",
")",
"{",
"return",
"new",
"response",
"entity",
"<",
">",
"(",
"http",
"status",
"not",
"implemented",
")",
";",
"}"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"return",
"options",
"as",
"{",
"@",
"link",
"options",
"parsing",
"result",
"}",
"so",
"the",
"options",
"can",
"'",
"t",
"be",
"easily",
"modified",
"after",
"we",
"'",
"ve",
"applied",
"the",
"invocation",
"policy"
] |
[
"options",
"parsing",
"result",
"get",
"options",
"result",
"(",
")",
"{",
"return",
"options",
"parser",
";",
"}"
] |
[
"find",
"a",
"{",
"@",
"link",
"sub",
"protocol",
"handler",
"}",
"for",
"the",
"given",
"session"
] |
[
"protected",
"final",
"sub",
"protocol",
"handler",
"find",
"protocol",
"handler",
"(",
"web",
"socket",
"session",
"session",
")",
"{",
"string",
"protocol",
"=",
"null",
";",
"try",
"{",
"protocol",
"=",
"session",
"get",
"accepted",
"protocol",
"(",
")",
";",
"}",
"catch",
"(",
"exception",
"ex",
")",
"{",
"/",
"/",
"shouldn",
"'",
"t",
"happen",
"logger",
"error",
"(",
"\"",
"failed",
"to",
"obtain",
"session",
"get",
"accepted",
"protocol",
"(",
")",
":",
"\"",
"+",
"\"",
"will",
"use",
"the",
"default",
"protocol",
"handler",
"(",
"if",
"configured",
")",
"\"",
",",
"ex",
")",
";",
"}",
"sub",
"protocol",
"handler",
"handler",
";",
"if",
"(",
"string",
"utils",
"has",
"length",
"(",
"protocol",
")",
")",
"{",
"handler",
"=",
"this",
"protocol",
"handler",
"lookup",
"get",
"(",
"protocol",
")",
";",
"if",
"(",
"handler",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"no",
"handler",
"for",
"'",
"\"",
"+",
"protocol",
"+",
"\"",
"'",
"among",
"\"",
"+",
"this",
"protocol",
"handler",
"lookup",
")",
";",
"}",
"}",
"else",
"{",
"if",
"(",
"this",
"default",
"protocol",
"handler",
"!",
"=",
"null",
")",
"{",
"handler",
"=",
"this",
"default",
"protocol",
"handler",
";",
"}",
"else",
"if",
"(",
"this",
"protocol",
"handlers",
"size",
"(",
")",
"=",
"=",
"1",
")",
"{",
"handler",
"=",
"this",
"protocol",
"handlers",
"iterator",
"(",
")",
"next",
"(",
")",
";",
"}",
"else",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"multiple",
"protocol",
"handlers",
"configured",
"and",
"\"",
"+",
"\"",
"no",
"protocol",
"was",
"negotiated",
"consider",
"configuring",
"a",
"default",
"sub",
"protocol",
"handler",
"\"",
")",
";",
"}",
"}",
"return",
"handler",
";",
"}"
] |
[
"notification",
"callback",
"when",
"the",
"server",
"changes",
"its",
"status"
] |
[
"public",
"void",
"server",
"status",
"change",
"(",
"server",
"status",
"old",
"status",
",",
"server",
"status",
"new",
"status",
")",
"throws",
"service",
"exception",
";"
] |
[
"get",
"the",
"length",
"of",
"this",
"file",
",",
"in",
"bytes"
] |
[
"public",
"long",
"get",
"len",
"(",
")",
"{",
"return",
"length",
";",
"}"
] |
[
"writes",
"a",
"{",
"@",
"link",
"bit",
"matrix",
"}",
"to",
"a",
"file",
"with",
"default",
"configuration"
] |
[
"public",
"static",
"void",
"write",
"to",
"path",
"(",
"bit",
"matrix",
"matrix",
",",
"string",
"format",
",",
"path",
"file",
")",
"throws",
"i",
"o",
"exception",
"{",
"write",
"to",
"path",
"(",
"matrix",
",",
"format",
",",
"file",
",",
"default",
"config",
")",
";",
"}"
] |
[
"get",
"r",
"type",
"resource",
"map"
] |
[
"public",
"map",
"<",
"r",
"type",
",",
"set",
"<",
"r",
"dot",
"txt",
"entry",
">",
">",
"get",
"r",
"type",
"resource",
"map",
"(",
")",
"{",
"return",
"this",
"r",
"type",
"resource",
"map",
";",
"}"
] |
[
"check",
"if",
"an",
"access",
"token",
"is",
"expired",
"return",
"true",
"when",
"token",
"is",
"expired",
",",
"false",
"otherwise"
] |
[
"public",
"static",
"boolean",
"is",
"block",
"token",
"expired",
"(",
"token",
"<",
"block",
"token",
"identifier",
">",
"token",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"block",
"token",
"secret",
"manager",
"is",
"token",
"expired",
"(",
"token",
")",
";",
"}"
] |
[
"returns",
"the",
"{",
"@",
"link",
"calling",
"convention",
"}"
] |
[
"public",
"calling",
"convention",
"get",
"calling",
"convention",
"(",
")",
"{",
"return",
"calling",
"convention",
";",
"}"
] |
[
"<",
"code",
">",
"map",
"&",
"lt",
";",
"string",
",",
"org",
"apache",
"dubbo",
"metadata",
"definition",
"protobuf",
"model",
"phone",
"number",
"&",
"gt",
";",
"double",
"map",
"=",
"9",
";",
"<",
"code",
">"
] |
[
"public",
"java",
"util",
"map",
"<",
"java",
"lang",
"string",
",",
"org",
"apache",
"dubbo",
"metadata",
"definition",
"protobuf",
"model",
"google",
"p",
"b",
"phone",
"number",
">",
"get",
"double",
"map",
"map",
"(",
")",
"{",
"return",
"internal",
"get",
"double",
"map",
"(",
")",
"get",
"map",
"(",
")",
";",
"}"
] |
[
"maximum",
"session",
"timeout",
"in",
"milliseconds",
",",
"-",
"1",
"if",
"unset"
] |
[
"public",
"int",
"get",
"max",
"session",
"timeout",
"(",
")",
"{",
"return",
"max",
"session",
"timeout",
";",
"}"
] |
[
"returns",
"a",
"two",
"-",
"or",
"three",
"-",
"element",
"array",
"containing",
"first",
"the",
"custom",
"data",
"flavor",
",",
"if",
"one",
"was",
"created",
"in",
"the",
"constructors",
",",
"second",
"the",
"default",
"{",
"@",
"link",
"#",
"data",
"flavor",
"}",
"associated",
"with",
"{",
"@",
"link",
"transferable",
"object",
"}",
",",
"and",
"third",
"the",
"{",
"@",
"link",
"java",
"awt",
"datatransfer",
"data",
"flavor",
"string",
"flavor",
"}"
] |
[
"public",
"java",
"awt",
"datatransfer",
"data",
"flavor",
"[",
"]",
"get",
"transfer",
"data",
"flavors",
"(",
")",
"{",
"if",
"(",
"custom",
"flavor",
"!",
"=",
"null",
")",
"return",
"new",
"java",
"awt",
"datatransfer",
"data",
"flavor",
"[",
"]",
"{",
"custom",
"flavor",
",",
"data",
"flavor",
",",
"java",
"awt",
"datatransfer",
"data",
"flavor",
"string",
"flavor",
"}",
";",
"/",
"/",
"end",
"/",
"/",
"flavors",
"/",
"/",
"array",
"else",
"return",
"new",
"java",
"awt",
"datatransfer",
"data",
"flavor",
"[",
"]",
"{",
"data",
"flavor",
",",
"java",
"awt",
"datatransfer",
"data",
"flavor",
"string",
"flavor",
"}",
";",
"/",
"/",
"end",
"/",
"/",
"flavors",
"/",
"/",
"array",
"}",
"/",
"/",
"end",
"get",
"transfer",
"data",
"flavors"
] |
[
"this",
"implementation",
"does",
"nothing"
] |
[
"public",
"void",
"endpoint",
"deactivation",
"(",
"message",
"endpoint",
"factory",
"message",
"endpoint",
"factory",
",",
"activation",
"spec",
"activation",
"spec",
")",
"{",
"}"
] |
[
"return",
"true",
"if",
"this",
"shape",
"or",
"null",
"object",
"is",
"equal",
"to",
"o"
] |
[
"public",
"boolean",
"equals",
"(",
"object",
"o",
")",
"{",
"return",
"super",
"equals",
"(",
"o",
")",
"&",
"&",
"objects",
"equals",
"(",
"this",
"additional",
"properties",
",",
"(",
"(",
"shape",
"or",
"null",
")",
"o",
")",
"additional",
"properties",
")",
";",
"}"
] |
[
"returns",
"the",
"procedure",
"length"
] |
[
"public",
"long",
"get",
"procedure",
"length",
"(",
")",
"{",
"return",
"procedure",
"length",
";",
"}"
] |
[
"returns",
"the",
"labels",
"that",
"might",
"appear",
"multiple",
"times",
"in",
"the",
"same",
"attribute",
"value"
] |
[
"public",
"set",
"<",
"label",
">",
"check",
"for",
"duplicate",
"labels",
"(",
"attribute",
"attribute",
")",
"{",
"string",
"attr",
"name",
"=",
"attribute",
"get",
"name",
"(",
")",
";",
"type",
"<",
"?",
">",
"attr",
"type",
"=",
"attribute",
"get",
"type",
"(",
")",
";",
"immutable",
"set",
"builder",
"<",
"label",
">",
"duplicates",
"=",
"null",
";",
"selector",
"list",
"<",
"?",
">",
"selector",
"list",
"=",
"get",
"selector",
"list",
"(",
"attribute",
"get",
"name",
"(",
")",
",",
"attr",
"type",
")",
";",
"if",
"(",
"selector",
"list",
"=",
"=",
"null",
"|",
"|",
"selector",
"list",
"get",
"selectors",
"(",
")",
"size",
"(",
")",
"=",
"=",
"1",
")",
"{",
"/",
"/",
"three",
"possible",
"scenarios",
":",
"/",
"/",
"1",
")",
"plain",
"old",
"attribute",
"(",
"no",
"selects",
")",
"without",
"selects",
",",
"visit",
"attribute",
"runs",
"efficiently",
"/",
"/",
"2",
")",
"computed",
"default",
",",
"possibly",
"depending",
"on",
"other",
"attributes",
"using",
"select",
"in",
"this",
"case",
",",
"/",
"/",
"visit",
"attribute",
"might",
"be",
"inefficient",
"but",
"we",
"have",
"no",
"choice",
"but",
"to",
"iterate",
"over",
"all",
"/",
"/",
"possible",
"values",
"(",
"since",
"we",
"have",
"to",
"compute",
"them",
")",
",",
"so",
"we",
"take",
"the",
"efficiency",
"hit",
"/",
"/",
"3",
")",
"\"",
"attr",
"=",
"select",
"(",
"{",
"}",
")",
"\"",
"with",
"just",
"a",
"single",
"select",
",",
"visit",
"attribute",
"runs",
"efficiently",
"for",
"(",
"object",
"value",
":",
"visit",
"attribute",
"(",
"attr",
"name",
",",
"attr",
"type",
")",
")",
"{",
"if",
"(",
"value",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"todo",
"(",
"bazel",
"-",
"team",
")",
":",
"calculate",
"duplicates",
"directly",
"using",
"attr",
"type",
"visit",
"labels",
"in",
"order",
"to",
"/",
"/",
"avoid",
"intermediate",
"collections",
"here",
"duplicates",
"=",
"add",
"duplicate",
"labels",
"(",
"duplicates",
",",
"extract",
"labels",
"(",
"attr",
"type",
",",
"value",
")",
")",
";",
"}",
"}",
"}",
"else",
"{",
"/",
"/",
"multiple",
"selects",
"concatenated",
"together",
"it",
"'",
"s",
"expensive",
"to",
"iterate",
"over",
"every",
"possible",
"/",
"/",
"value",
",",
"so",
"instead",
"collect",
"all",
"labels",
"across",
"all",
"the",
"selects",
"and",
"check",
"for",
"duplicates",
"/",
"/",
"this",
"is",
"overly",
"strict",
",",
"since",
"this",
"counts",
"duplicates",
"across",
"values",
"we",
"can",
"presumably",
"/",
"/",
"relax",
"this",
"if",
"necessary",
",",
"but",
"doing",
"so",
"would",
"incur",
"the",
"value",
"iteration",
"expense",
"this",
"/",
"/",
"code",
"path",
"avoids",
"list",
"<",
"label",
">",
"combined",
"labels",
"=",
"new",
"linked",
"list",
"<",
">",
"(",
")",
";",
"/",
"/",
"labels",
"that",
"appear",
"across",
"all",
"selectors",
"for",
"(",
"selector",
"<",
"?",
">",
"selector",
":",
"selector",
"list",
"get",
"selectors",
"(",
")",
")",
"{",
"/",
"/",
"labels",
"within",
"a",
"single",
"selector",
"it",
"'",
"s",
"okay",
"for",
"there",
"to",
"be",
"duplicates",
"as",
"long",
"as",
"/",
"/",
"they",
"'",
"re",
"in",
"different",
"selector",
"paths",
"(",
"since",
"only",
"one",
"path",
"can",
"actually",
"get",
"chosen",
")",
"set",
"<",
"label",
">",
"selector",
"labels",
"=",
"new",
"linked",
"hash",
"set",
"<",
">",
"(",
")",
";",
"for",
"(",
"object",
"selector",
"value",
":",
"selector",
"get",
"entries",
"(",
")",
"values",
"(",
")",
")",
"{",
"list",
"<",
"label",
">",
"labels",
"in",
"selector",
"value",
"=",
"extract",
"labels",
"(",
"attr",
"type",
",",
"selector",
"value",
")",
";",
"/",
"/",
"duplicates",
"within",
"a",
"single",
"path",
"are",
"not",
"okay",
"duplicates",
"=",
"add",
"duplicate",
"labels",
"(",
"duplicates",
",",
"labels",
"in",
"selector",
"value",
")",
";",
"iterables",
"add",
"all",
"(",
"selector",
"labels",
",",
"labels",
"in",
"selector",
"value",
")",
";",
"}",
"combined",
"labels",
"add",
"all",
"(",
"selector",
"labels",
")",
";",
"}",
"duplicates",
"=",
"add",
"duplicate",
"labels",
"(",
"duplicates",
",",
"combined",
"labels",
")",
";",
"}",
"return",
"duplicates",
"=",
"=",
"null",
"?",
"immutable",
"set",
"of",
"(",
")",
":",
"duplicates",
"build",
"(",
")",
";",
"}"
] |
[
"<",
"code",
">",
"optional",
"string",
"name",
"=",
"6",
";",
"<",
"code",
">"
] |
[
"public",
"com",
"google",
"protobuf",
"byte",
"string",
"get",
"name",
"bytes",
"(",
")",
"{",
"object",
"ref",
"=",
"name",
";",
"if",
"(",
"ref",
"instanceof",
"string",
")",
"{",
"com",
"google",
"protobuf",
"byte",
"string",
"b",
"=",
"com",
"google",
"protobuf",
"byte",
"string",
"copy",
"from",
"utf",
"8",
"(",
"(",
"string",
")",
"ref",
")",
";",
"name",
"=",
"b",
";",
"return",
"b",
";",
"}",
"else",
"{",
"return",
"(",
"com",
"google",
"protobuf",
"byte",
"string",
")",
"ref",
";",
"}",
"}"
] |
[
"add",
"an",
"attribute",
"with",
"the",
"given",
"name",
"and",
"value",
"to",
"the",
"last",
"route",
"built",
"with",
"this",
"builder"
] |
[
"builder",
"with",
"attribute",
"(",
"string",
"name",
",",
"object",
"value",
")",
";"
] |
[
"finds",
"the",
"timeline",
"corresponding",
"to",
"a",
"component"
] |
[
"public",
"static",
"@",
"nullable",
"tree",
"revisions",
"get",
"timeline",
"(",
"debug",
"component",
"component",
")",
"{",
"return",
"component",
"get",
"context",
"(",
")",
"get",
"component",
"tree",
"(",
")",
"get",
"timeline",
"(",
")",
";",
"}"
] |
[
"model",
"tests",
"for",
"child",
"cat"
] |
[
"public",
"void",
"test",
"child",
"cat",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"child",
"cat",
"}"
] |
[
"returns",
"the",
"model",
"for",
"this",
"tree"
] |
[
"public",
"g",
"tree",
"model",
"get",
"model",
"(",
")",
"{",
"return",
"model",
";",
"}"
] |
[
"find",
"the",
"fields",
"constant",
"that",
"matches",
"field",
"id",
",",
"throwing",
"an",
"exception",
"if",
"it",
"is",
"not",
"found"
] |
[
"public",
"static",
"fields",
"find",
"by",
"thrift",
"id",
"or",
"throw",
"(",
"int",
"field",
"id",
")",
"{",
"fields",
"fields",
"=",
"find",
"by",
"thrift",
"id",
"(",
"field",
"id",
")",
";",
"if",
"(",
"fields",
"=",
"=",
"null",
")",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"field",
"\"",
"+",
"field",
"id",
"+",
"\"",
"doesn",
"'",
"t",
"exist",
"!",
"\"",
")",
";",
"return",
"fields",
";",
"}"
] |
[
"creates",
"an",
"external",
"reference",
"from",
"the",
"given",
"data",
"the",
"reference",
"type",
"{",
"@",
"link",
"ref",
"type",
"#",
"data",
"}",
"will",
"be",
"used"
] |
[
"public",
"final",
"reference",
"create",
"external",
"reference",
"(",
"data",
"data",
",",
"string",
"library",
"name",
",",
"string",
"external",
"label",
",",
"address",
"external",
"addr",
")",
"throws",
"exception",
"{",
"reference",
"manager",
"reference",
"manager",
"=",
"current",
"program",
"get",
"reference",
"manager",
"(",
")",
";",
"reference",
"reference",
"=",
"reference",
"manager",
"add",
"external",
"reference",
"(",
"data",
"get",
"min",
"address",
"(",
")",
",",
"library",
"name",
",",
"external",
"label",
",",
"external",
"addr",
",",
"source",
"type",
"user",
"defined",
",",
"0",
",",
"ref",
"type",
"data",
")",
";",
"return",
"reference",
";",
"}"
] |
[
"returns",
"the",
"array",
"component",
"type",
"if",
"this",
"type",
"represents",
"an",
"array",
"(",
"{",
"@",
"code",
"int",
"[",
"]",
"}",
",",
"{",
"@",
"code",
"t",
"[",
"]",
"}",
",",
"{",
"@",
"code",
"<",
"?",
"extends",
"map",
"<",
"string",
",",
"integer",
">",
"[",
"]",
">",
"}",
"etc",
")",
",",
"or",
"else",
"{",
"@",
"code",
"null",
"}",
"is",
"returned"
] |
[
"public",
"final",
"type",
"token",
"<",
"?",
">",
"get",
"component",
"type",
"(",
")",
"{",
"type",
"component",
"type",
"=",
"types",
"get",
"component",
"type",
"(",
"runtime",
"type",
")",
";",
"if",
"(",
"component",
"type",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"return",
"of",
"(",
"component",
"type",
")",
";",
"}"
] |
[
"creates",
"collector",
"limiting",
"the",
"collection",
"to",
"the",
"first",
"<",
"code",
">",
"num",
"hits",
"<",
"code",
">",
"documents"
] |
[
"static",
"query",
"collector",
"context",
"create",
"early",
"termination",
"collector",
"context",
"(",
"int",
"num",
"hits",
")",
"{",
"return",
"new",
"query",
"collector",
"context",
"(",
"reason",
"search",
"terminate",
"after",
"count",
")",
"{",
"private",
"collector",
"collector",
";"
] |
[
"the",
"data",
"location"
] |
[
"public",
"path",
"[",
"]",
"data",
"files",
"(",
")",
"{",
"return",
"data",
"files",
";",
"}"
] |
[
"get",
"float",
"minimum",
":",
"54",
"3",
"maximum",
":",
"987",
"6"
] |
[
"public",
"float",
"get",
"float",
"(",
")",
"{",
"return",
"float",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}"
] |
[
"protected",
"int",
"compare",
"to",
"0",
"(",
"offsetted",
"item",
"other",
")",
"{",
"string",
"data",
"item",
"other",
"data",
"=",
"(",
"string",
"data",
"item",
")",
"other",
";",
"return",
"value",
"compare",
"to",
"(",
"other",
"data",
"value",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"array",
"enum",
"'"
] |
[
"public",
"void",
"array",
"enum",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"array",
"enum",
"}"
] |
[
"sets",
"the",
"data",
"held",
"by",
"this",
"window"
] |
[
"public",
"window",
"set",
"(",
"object",
"uid",
",",
"@",
"nullable",
"media",
"item",
"media",
"item",
",",
"@",
"nullable",
"object",
"manifest",
",",
"long",
"presentation",
"start",
"time",
"ms",
",",
"long",
"window",
"start",
"time",
"ms",
",",
"long",
"elapsed",
"realtime",
"epoch",
"offset",
"ms",
",",
"boolean",
"is",
"seekable",
",",
"boolean",
"is",
"dynamic",
",",
"boolean",
"is",
"live",
",",
"long",
"default",
"position",
"us",
",",
"long",
"duration",
"us",
",",
"int",
"first",
"period",
"index",
",",
"int",
"last",
"period",
"index",
",",
"long",
"position",
"in",
"first",
"period",
"us",
")",
"{",
"this",
"uid",
"=",
"uid",
";",
"this",
"media",
"item",
"=",
"media",
"item",
"!",
"=",
"null",
"?",
"media",
"item",
":",
"empty",
"media",
"item",
";",
"this",
"tag",
"=",
"media",
"item",
"!",
"=",
"null",
"&",
"&",
"media",
"item",
"playback",
"properties",
"!",
"=",
"null",
"?",
"media",
"item",
"playback",
"properties",
"tag",
":",
"null",
";",
"this",
"manifest",
"=",
"manifest",
";",
"this",
"presentation",
"start",
"time",
"ms",
"=",
"presentation",
"start",
"time",
"ms",
";",
"this",
"window",
"start",
"time",
"ms",
"=",
"window",
"start",
"time",
"ms",
";",
"this",
"elapsed",
"realtime",
"epoch",
"offset",
"ms",
"=",
"elapsed",
"realtime",
"epoch",
"offset",
"ms",
";",
"this",
"is",
"seekable",
"=",
"is",
"seekable",
";",
"this",
"is",
"dynamic",
"=",
"is",
"dynamic",
";",
"this",
"is",
"live",
"=",
"is",
"live",
";",
"this",
"default",
"position",
"us",
"=",
"default",
"position",
"us",
";",
"this",
"duration",
"us",
"=",
"duration",
"us",
";",
"this",
"first",
"period",
"index",
"=",
"first",
"period",
"index",
";",
"this",
"last",
"period",
"index",
"=",
"last",
"period",
"index",
";",
"this",
"position",
"in",
"first",
"period",
"us",
"=",
"position",
"in",
"first",
"period",
"us",
";",
"this",
"is",
"placeholder",
"=",
"false",
";",
"return",
"this",
";",
"}"
] |
[
"calculate",
"hilbert",
"index",
"of",
"coordinates",
"in",
"rectangle",
"this",
"gives",
"a",
"reasonable",
"index",
"for",
"coordinates",
"contained",
"in",
"the",
"bounding",
"rectangle",
";",
"coordinates",
"not",
"in",
"the",
"box",
"will",
"return",
"`",
"long",
"max",
"value",
"`"
] |
[
"public",
"long",
"index",
"of",
"(",
"double",
"x",
",",
"double",
"y",
")",
"{",
"if",
"(",
"!",
"rectangle",
"contains",
"(",
"x",
",",
"y",
")",
")",
"{",
"/",
"/",
"put",
"things",
"outside",
"the",
"box",
"at",
"the",
"end",
"/",
"/",
"this",
"will",
"also",
"handle",
"infinities",
"and",
"na",
"ns",
"return",
"long",
"max",
"value",
";",
"}",
"int",
"x",
"int",
"=",
"(",
"int",
")",
"(",
"x",
"scale",
"*",
"(",
"x",
"-",
"rectangle",
"get",
"x",
"min",
"(",
")",
")",
")",
";",
"int",
"y",
"int",
"=",
"(",
"int",
")",
"(",
"y",
"scale",
"*",
"(",
"y",
"-",
"rectangle",
"get",
"y",
"min",
"(",
")",
")",
")",
";",
"return",
"discrete",
"index",
"of",
"(",
"x",
"int",
",",
"y",
"int",
")",
";",
"}"
] |
[
"set",
"the",
"trigger",
"'",
"s",
"job",
"data",
"map"
] |
[
"public",
"void",
"set",
"job",
"data",
"map",
"(",
"job",
"data",
"map",
"job",
"data",
"map",
")",
"{",
"this",
"job",
"data",
"map",
"=",
"job",
"data",
"map",
";",
"}"
] |
[
"load",
"{",
"@",
"link",
"system",
"rule",
"}",
"s",
",",
"former",
"rules",
"will",
"be",
"replaced"
] |
[
"public",
"static",
"void",
"load",
"rules",
"(",
"list",
"<",
"system",
"rule",
">",
"rules",
")",
"{",
"current",
"property",
"update",
"value",
"(",
"rules",
")",
";",
"}"
] |
[
"returns",
"{",
"@",
"code",
"true",
"}",
"if",
"i",
"pv",
"4",
"should",
"be",
"used",
"even",
"if",
"the",
"system",
"supports",
"both",
"i",
"pv",
"4",
"and",
"i",
"pv",
"6",
"setting",
"this",
"property",
"to",
"{",
"@",
"code",
"true",
"}",
"will",
"disable",
"i",
"pv",
"6",
"support",
"the",
"default",
"value",
"of",
"this",
"property",
"is",
"{",
"@",
"code",
"false",
"}"
] |
[
"public",
"static",
"boolean",
"is",
"ip",
"v",
"4",
"stack",
"preferred",
"(",
")",
"{",
"return",
"ipv4",
"preferred",
";",
"}"
] |
[
"declares",
"that",
"instances",
"of",
"this",
"rule",
"are",
"restricted",
"to",
"the",
"specified",
"environments",
",",
"i",
"e",
"these",
"override",
"the",
"defaults",
"declared",
"by",
"their",
"environment",
"groups",
"this",
"can",
"be",
"overridden",
"by",
"rule",
"-",
"specific",
"declarations",
"see",
"{",
"@",
"link",
"com",
"google",
"devtools",
"build",
"lib",
"analysis",
"constraints",
"constraint",
"semantics",
"}",
"for",
"details",
"the",
"input",
"list",
"cannot",
"be",
"empty"
] |
[
"public",
"<",
"type",
">",
"builder",
"restricted",
"to",
"(",
"label",
"first",
"environment",
",",
"label",
"other",
"environments",
")",
"{",
"immutable",
"list",
"<",
"label",
">",
"environments",
"=",
"immutable",
"list",
"<",
"label",
">",
"builder",
"(",
")",
"add",
"(",
"first",
"environment",
")",
"add",
"(",
"other",
"environments",
")",
"build",
"(",
")",
";",
"add",
"(",
"attr",
"(",
"default",
"restricted",
"environment",
"attr",
",",
"label",
"list",
")",
"value",
"(",
"environments",
")",
")",
";",
"return",
"this",
";",
"}"
] |
[
"returns",
"a",
"request",
"to",
"load",
"the",
"given",
"byte",
"array",
"note",
"-",
"by",
"default",
"loads",
"for",
"bytes",
"are",
"not",
"cached",
"in",
"either",
"the",
"memory",
"or",
"the",
"disk",
"cache"
] |
[
"public",
"request",
"builder",
"<",
"transcode",
"type",
">",
"load",
"(",
"@",
"nullable",
"byte",
"[",
"]",
"model",
")",
"{",
"request",
"builder",
"<",
"transcode",
"type",
">",
"result",
"=",
"load",
"generic",
"(",
"model",
")",
";",
"if",
"(",
"!",
"result",
"is",
"disk",
"cache",
"strategy",
"set",
"(",
")",
")",
"{",
"result",
"=",
"result",
"apply",
"(",
"disk",
"cache",
"strategy",
"of",
"(",
"disk",
"cache",
"strategy",
"none",
")",
")",
";",
"}",
"if",
"(",
"!",
"result",
"is",
"skip",
"memory",
"cache",
"set",
"(",
")",
")",
"{",
"result",
"=",
"result",
"apply",
"(",
"skip",
"memory",
"cache",
"of",
"(",
"true",
"/",
"*",
"skip",
"memory",
"cache",
"*",
"/",
")",
")",
";",
"}",
"return",
"result",
";",
"}"
] |
[
"returns",
"true",
"if",
"this",
"file",
"is",
"a",
"directory",
"always",
"returns",
"false",
"for",
"classpath",
"files",
"on",
"android",
",",
"an",
"{",
"@",
"link",
"file",
"type",
"#",
"internal",
"}",
"handle",
"to",
"an",
"empty",
"directory",
"will",
"return",
"false",
"on",
"the",
"desktop",
",",
"an",
"{",
"@",
"link",
"file",
"type",
"#",
"internal",
"}",
"handle",
"to",
"a",
"directory",
"on",
"the",
"classpath",
"will",
"return",
"false"
] |
[
"public",
"boolean",
"is",
"directory",
"(",
")",
"{",
"if",
"(",
"type",
"=",
"=",
"file",
"type",
"classpath",
")",
"return",
"false",
";",
"return",
"file",
"(",
")",
"is",
"directory",
"(",
")",
";",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}",
"the",
"default",
"implementation",
"returns",
"the",
"result",
"of",
"calling",
"{",
"@",
"link",
"#",
"visit",
"children",
"}",
"on",
"{",
"@",
"code",
"ctx",
"}"
] |
[
"@",
"override",
"public",
"t",
"visit",
"newarray",
"(",
"painless",
"parser",
"newarray",
"context",
"ctx",
")",
"{",
"return",
"visit",
"children",
"(",
"ctx",
")",
";",
"}"
] |
[
"each",
"value",
"of",
"the",
"parameter",
"annotations",
"table",
"represents",
"all",
"of",
"the",
"runtimevisible",
"annotations",
"on",
"a",
"single",
"parameter",
"the",
"sequence",
"of",
"values",
"in",
"the",
"table",
"corresponds",
"to",
"the",
"sequence",
"of",
"parameters",
"in",
"the",
"method",
"descriptor",
"each",
"parameter",
"annotations",
"entry",
"contains",
"the",
"following",
"two",
"items",
":",
"num",
"annotations",
"the",
"value",
"of",
"the",
"num",
"annotations",
"item",
"indicates",
"the",
"number",
"of",
"runtimevisible",
"annotations",
"on",
"the",
"parameter",
"corresponding",
"to",
"the",
"sequence",
"number",
"of",
"this",
"parameter",
"annotations",
"element",
"annotations",
"each",
"value",
"of",
"the",
"annotations",
"table",
"represents",
"a",
"single",
"runtime",
"-",
"visible",
"annotation",
"on",
"the",
"parameter",
"corresponding",
"to",
"the",
"sequence",
"number",
"of",
"this",
"parameter",
"annotations",
"element"
] |
[
"public",
"annotation",
"java",
"[",
"]",
"get",
"parameter",
"annotations",
"(",
"int",
"parameter",
")",
"{",
"return",
"parameter",
"annotations",
"get",
"(",
"parameter",
")",
";",
"}"
] |
[
"returns",
"the",
"current",
"setting",
"for",
"max",
"replication",
"streams",
"hard",
"limit",
",",
"set",
"by",
"{",
"@",
"code",
"d",
"f",
"s",
"config",
"keys",
"dfs",
"namenode",
"replication",
"streams",
"hard",
"limit",
"key",
"}"
] |
[
"public",
"int",
"get",
"replication",
"streams",
"hard",
"limit",
"(",
")",
"{",
"return",
"replication",
"streams",
"hard",
"limit",
";",
"}"
] |
[
"removes",
"an",
"entry",
"whose",
"value",
"has",
"been",
"garbage",
"collected"
] |
[
"boolean",
"reclaim",
"value",
"(",
"k",
"key",
",",
"int",
"hash",
",",
"weak",
"value",
"reference",
"<",
"k",
",",
"v",
",",
"e",
">",
"value",
"reference",
")",
"{",
"lock",
"(",
")",
";",
"try",
"{",
"int",
"new",
"count",
"=",
"this",
"count",
"-",
"1",
";",
"atomic",
"reference",
"array",
"<",
"e",
">",
"table",
"=",
"this",
"table",
";",
"int",
"index",
"=",
"hash",
"&",
"(",
"table",
"length",
"(",
")",
"-",
"1",
")",
";",
"e",
"first",
"=",
"table",
"get",
"(",
"index",
")",
";",
"for",
"(",
"e",
"e",
"=",
"first",
";",
"e",
"!",
"=",
"null",
";",
"e",
"=",
"e",
"get",
"next",
"(",
")",
")",
"{",
"k",
"entry",
"key",
"=",
"e",
"get",
"key",
"(",
")",
";",
"if",
"(",
"e",
"get",
"hash",
"(",
")",
"=",
"=",
"hash",
"&",
"&",
"entry",
"key",
"!",
"=",
"null",
"&",
"&",
"map",
"key",
"equivalence",
"equivalent",
"(",
"key",
",",
"entry",
"key",
")",
")",
"{",
"weak",
"value",
"reference",
"<",
"k",
",",
"v",
",",
"e",
">",
"v",
"=",
"(",
"(",
"weak",
"value",
"entry",
"<",
"k",
",",
"v",
",",
"e",
">",
")",
"e",
")",
"get",
"value",
"reference",
"(",
")",
";",
"if",
"(",
"v",
"=",
"=",
"value",
"reference",
")",
"{",
"+",
"+",
"mod",
"count",
";",
"e",
"new",
"first",
"=",
"remove",
"from",
"chain",
"(",
"first",
",",
"e",
")",
";",
"new",
"count",
"=",
"this",
"count",
"-",
"1",
";",
"table",
"set",
"(",
"index",
",",
"new",
"first",
")",
";",
"this",
"count",
"=",
"new",
"count",
";",
"/",
"/",
"write",
"-",
"volatile",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}",
"}",
"return",
"false",
";",
"}",
"finally",
"{",
"unlock",
"(",
")",
";",
"}",
"}"
] |
[
"determine",
"if",
"the",
"supplied",
"descriptor",
"is",
"for",
"a",
"supported",
"number",
"type",
"or",
"boolean",
"the",
"compilation",
"process",
"only",
"(",
"currently",
")",
"supports",
"certain",
"number",
"types",
"these",
"are",
"double",
",",
"float",
",",
"long",
"and",
"int"
] |
[
"public",
"static",
"boolean",
"is",
"primitive",
"or",
"unboxable",
"supported",
"number",
"or",
"boolean",
"(",
"@",
"nullable",
"string",
"descriptor",
")",
"{",
"if",
"(",
"descriptor",
"=",
"=",
"null",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"is",
"primitive",
"or",
"unboxable",
"supported",
"number",
"(",
"descriptor",
")",
")",
"{",
"return",
"true",
";",
"}",
"return",
"(",
"\"",
"z",
"\"",
"equals",
"(",
"descriptor",
")",
"|",
"|",
"descriptor",
"equals",
"(",
"\"",
"ljava",
"/",
"lang",
"/",
"boolean",
"\"",
")",
")",
";",
"}"
] |
[
"if",
"the",
"argument",
"is",
"a",
"{",
"@",
"linkplain",
"#",
"is",
"lower",
"case",
"(",
"char",
")",
"lowercase",
"ascii",
"character",
"}",
"returns",
"the",
"uppercase",
"equivalent",
"otherwise",
"returns",
"the",
"argument"
] |
[
"public",
"static",
"char",
"to",
"upper",
"case",
"(",
"char",
"c",
")",
"{",
"return",
"is",
"lower",
"case",
"(",
"c",
")",
"?",
"(",
"char",
")",
"(",
"c",
"^",
"case",
"mask",
")",
":",
"c",
";",
"}"
] |
[
"syncs",
"operation",
"result",
"to",
"the",
"translog",
"or",
"throws",
"a",
"shard",
"not",
"available",
"failure"
] |
[
"protected",
"static",
"location",
"sync",
"operation",
"result",
"or",
"throw",
"(",
"final",
"engine",
"result",
"operation",
"result",
",",
"final",
"location",
"current",
"location",
")",
"throws",
"exception",
"{",
"final",
"location",
"location",
";",
"if",
"(",
"operation",
"result",
"get",
"failure",
"(",
")",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"check",
"if",
"any",
"transient",
"write",
"operation",
"failures",
"should",
"be",
"bubbled",
"up",
"exception",
"failure",
"=",
"operation",
"result",
"get",
"failure",
"(",
")",
";",
"assert",
"failure",
"instanceof",
"mapper",
"parsing",
"exception",
":",
"\"",
"expected",
"mapper",
"parsing",
"failures",
"got",
"\"",
"+",
"failure",
";",
"throw",
"failure",
";",
"}",
"else",
"{",
"location",
"=",
"location",
"to",
"sync",
"(",
"current",
"location",
",",
"operation",
"result",
"get",
"translog",
"location",
"(",
")",
")",
";",
"}",
"return",
"location",
";",
"}"
] |
[
"specify",
"the",
"http",
"server",
"'",
"s",
"hostname",
"to",
"bind",
"to",
"default",
"is",
"localhost",
";",
"can",
"be",
"overridden",
"with",
"a",
"specific",
"network",
"address",
"to",
"bind",
"to",
"only",
"applicable",
"for",
"a",
"locally",
"configured",
"http",
"server",
"ignored",
"when",
"the",
"{",
"@",
"link",
"#",
"set",
"server",
"\"",
"server",
"\"",
"}",
"property",
"has",
"been",
"specified"
] |
[
"public",
"void",
"set",
"hostname",
"(",
"string",
"hostname",
")",
"{",
"this",
"hostname",
"=",
"hostname",
";",
"}"
] |
[
"initiates",
"an",
"iterative",
"part",
"of",
"the",
"program",
"that",
"executes",
"multiple",
"times",
"and",
"feeds",
"back",
"data",
"sets",
"the",
"iterative",
"part",
"needs",
"to",
"be",
"closed",
"by",
"calling",
"{",
"@",
"link",
"org",
"apache",
"flink",
"api",
"java",
"operators",
"iterative",
"data",
"set",
"#",
"close",
"with",
"(",
"data",
"set",
")",
"}",
"the",
"data",
"set",
"given",
"to",
"the",
"{",
"@",
"code",
"close",
"with",
"(",
"data",
"set",
")",
"}",
"method",
"is",
"the",
"data",
"set",
"that",
"will",
"be",
"fed",
"back",
"and",
"used",
"as",
"the",
"input",
"to",
"the",
"next",
"iteration",
"the",
"return",
"value",
"of",
"the",
"{",
"@",
"code",
"close",
"with",
"(",
"data",
"set",
")",
"}",
"method",
"is",
"the",
"resulting",
"data",
"set",
"after",
"the",
"iteration",
"has",
"terminated",
"an",
"example",
"of",
"an",
"iterative",
"computation",
"is",
"as",
"follows",
":",
"{",
"@",
"code",
"data",
"set",
"<",
"double",
">",
"input",
"=",
";",
"data",
"set",
"<",
"double",
">",
"start",
"of",
"iteration",
"=",
"input",
"iterate",
"(",
"10",
")",
";",
"data",
"set",
"<",
"double",
">",
"to",
"be",
"fed",
"back",
"=",
"start",
"of",
"iteration",
"map",
"(",
"new",
"my",
"mapper",
"(",
")",
")",
"group",
"by",
"(",
")",
"reduce",
"group",
"(",
"new",
"my",
"reducer",
"(",
")",
")",
";",
"data",
"set",
"<",
"double",
">",
"result",
"=",
"start",
"of",
"iteration",
"close",
"with",
"(",
"to",
"be",
"fed",
"back",
")",
";",
"}",
"the",
"iteration",
"has",
"a",
"maximum",
"number",
"of",
"times",
"that",
"it",
"executes",
"a",
"dynamic",
"termination",
"can",
"be",
"realized",
"by",
"using",
"a",
"termination",
"criterion",
"(",
"see",
"{",
"@",
"link",
"org",
"apache",
"flink",
"api",
"java",
"operators",
"iterative",
"data",
"set",
"#",
"close",
"with",
"(",
"data",
"set",
",",
"data",
"set",
")",
"}",
")"
] |
[
"public",
"iterative",
"data",
"set",
"<",
"t",
">",
"iterate",
"(",
"int",
"max",
"iterations",
")",
"{",
"return",
"new",
"iterative",
"data",
"set",
"<",
">",
"(",
"get",
"execution",
"environment",
"(",
")",
",",
"get",
"type",
"(",
")",
",",
"this",
",",
"max",
"iterations",
")",
";",
"}"
] |
[
"the",
"value",
"assigned",
"to",
"this",
"element",
"<",
"code",
">",
"optional",
"aapt",
"pb",
"item",
"item",
"=",
"3",
";",
"<",
"code",
">"
] |
[
"private",
"void",
"clear",
"item",
"(",
")",
"{",
"item",
"=",
"null",
";",
"bit",
"field",
"0",
"=",
"(",
"bit",
"field",
"0",
"&",
"~",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"4",
")",
";",
"}"
] |
[
"\"",
"overrides",
"\"",
"the",
"static",
"method",
"in",
"{",
"@",
"link",
"managed",
"channel",
"builder",
"}"
] |
[
"public",
"static",
"final",
"google",
"default",
"channel",
"builder",
"for",
"target",
"(",
"string",
"target",
")",
"{",
"return",
"new",
"google",
"default",
"channel",
"builder",
"(",
"target",
")",
";",
"}"
] |
[
"<",
"code",
">",
"optional",
"int",
"3",
"2",
"age",
"=",
"3",
";",
"<",
"code",
">"
] |
[
"public",
"boolean",
"has",
"age",
"(",
")",
"{",
"return",
"(",
"(",
"bit",
"field",
"0",
"&",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"4",
")",
"=",
"=",
"0x",
"0",
"0",
"0",
"0",
"0",
"0",
"0",
"4",
")",
";",
"}"
] |
[
"aggregate",
"the",
"values",
"of",
"records",
"in",
"these",
"streams",
"by",
"the",
"grouped",
"key",
"records",
"with",
"{",
"@",
"code",
"null",
"}",
"key",
"or",
"value",
"are",
"ignored",
"the",
"result",
"is",
"written",
"into",
"a",
"local",
"{",
"@",
"link",
"key",
"value",
"store",
"}",
"(",
"which",
"is",
"basically",
"an",
"ever",
"-",
"updating",
"materialized",
"view",
")",
"that",
"can",
"be",
"queried",
"by",
"the",
"given",
"store",
"name",
"in",
"{",
"@",
"code",
"materialized",
"}",
"furthermore",
",",
"updates",
"to",
"the",
"store",
"are",
"sent",
"downstream",
"into",
"a",
"{",
"@",
"link",
"k",
"table",
"}",
"changelog",
"stream",
"to",
"compute",
"the",
"aggregation",
"the",
"corresponding",
"{",
"@",
"link",
"aggregator",
"}",
"as",
"specified",
"in",
"{",
"@",
"link",
"#",
"cogroup",
"(",
"k",
"grouped",
"stream",
",",
"aggregator",
")",
"cogroup",
"(",
")",
"}",
"is",
"used",
"per",
"input",
"stream",
"the",
"specified",
"{",
"@",
"link",
"initializer",
"}",
"is",
"applied",
"once",
"per",
"key",
",",
"directly",
"before",
"the",
"first",
"input",
"record",
"per",
"key",
"is",
"processed",
"to",
"provide",
"an",
"initial",
"intermediate",
"aggregation",
"result",
"that",
"is",
"used",
"to",
"process",
"the",
"first",
"record",
"the",
"specified",
"{",
"@",
"link",
"named",
"}",
"is",
"applied",
"once",
"to",
"the",
"processor",
"combining",
"the",
"grouped",
"streams",
"not",
"all",
"updates",
"might",
"get",
"sent",
"downstream",
",",
"as",
"an",
"internal",
"cache",
"is",
"used",
"to",
"deduplicate",
"consecutive",
"updates",
"to",
"the",
"same",
"key",
"the",
"rate",
"of",
"propagated",
"updates",
"depends",
"on",
"your",
"input",
"data",
"rate",
",",
"the",
"number",
"of",
"distinct",
"keys",
",",
"the",
"number",
"of",
"parallel",
"running",
"kafka",
"streams",
"instances",
",",
"and",
"the",
"{",
"@",
"link",
"streams",
"config",
"configuration",
"}",
"parameters",
"for",
"{",
"@",
"link",
"streams",
"config",
"#",
"cache",
"max",
"bytes",
"buffering",
"config",
"cache",
"size",
"}",
",",
"and",
"{",
"@",
"link",
"streams",
"config",
"#",
"commit",
"interval",
"ms",
"config",
"commit",
"interval",
"}",
"to",
"query",
"the",
"local",
"{",
"@",
"link",
"read",
"only",
"key",
"value",
"store",
"}",
"it",
"must",
"be",
"obtained",
"via",
"{",
"@",
"link",
"kafka",
"streams",
"#",
"store",
"(",
"store",
"query",
"parameters",
")",
"kafka",
"streams",
"#",
"store",
"(",
")",
"}",
":",
"{",
"@",
"code",
"kafka",
"streams",
"streams",
"=",
"some",
"aggregation",
"on",
"value",
"type",
"double",
"string",
"queryable",
"store",
"name",
"=",
"\"",
"store",
"name",
"\"",
"the",
"store",
"name",
"should",
"be",
"the",
"name",
"of",
"the",
"store",
"as",
"defined",
"by",
"the",
"materialized",
"instance",
"read",
"only",
"key",
"value",
"store",
"<",
"k",
",",
"value",
"and",
"timestamp",
"<",
"v",
"out",
">",
">",
"local",
"store",
"=",
"streams",
"store",
"(",
"queryable",
"store",
"name",
",",
"queryable",
"store",
"types",
"<",
"k",
",",
"value",
"and",
"timestamp",
"<",
"v",
"out",
">",
">",
"timestamped",
"key",
"value",
"store",
"(",
")",
")",
";",
"k",
"key",
"=",
"\"",
"some",
"-",
"key",
"\"",
";",
"value",
"and",
"timestamp",
"<",
"v",
"out",
">",
"agg",
"for",
"key",
"=",
"local",
"store",
"get",
"(",
"key",
")",
";",
"key",
"must",
"be",
"local",
"(",
"application",
"state",
"is",
"shared",
"over",
"all",
"running",
"kafka",
"streams",
"instances",
")",
"}",
"for",
"non",
"-",
"local",
"keys",
",",
"a",
"custom",
"rpc",
"mechanism",
"must",
"be",
"implemented",
"using",
"{",
"@",
"link",
"kafka",
"streams",
"#",
"all",
"metadata",
"(",
")",
"}",
"to",
"query",
"the",
"value",
"of",
"the",
"key",
"on",
"a",
"parallel",
"running",
"instance",
"of",
"your",
"kafka",
"streams",
"application",
"for",
"failure",
"and",
"recovery",
"the",
"store",
"(",
"which",
"always",
"will",
"be",
"of",
"type",
"{",
"@",
"link",
"timestamped",
"key",
"value",
"store",
"}",
")",
"will",
"be",
"backed",
"by",
"an",
"internal",
"changelog",
"topic",
"that",
"will",
"be",
"created",
"in",
"kafka",
"therefore",
",",
"the",
"store",
"name",
"defined",
"by",
"the",
"materialized",
"instance",
"must",
"be",
"a",
"valid",
"kafka",
"topic",
"name",
"and",
"cannot",
"contain",
"characters",
"other",
"than",
"ascii",
"alphanumerics",
",",
"'",
"'",
",",
"'",
"'",
"and",
"'",
"-",
"'",
"the",
"changelog",
"topic",
"will",
"be",
"named",
"\"",
"$",
"{",
"application",
"id",
"}",
"-",
"$",
"{",
"store",
"name",
"}",
"-",
"changelog",
"\"",
",",
"where",
"\"",
"application",
"id",
"\"",
"is",
"user",
"-",
"specified",
"in",
"{",
"@",
"link",
"streams",
"config",
"}",
"via",
"parameter",
"{",
"@",
"link",
"streams",
"config",
"#",
"application",
"id",
"config",
"application",
"id",
"config",
"}",
",",
"\"",
"store",
"name",
"\"",
"is",
"the",
"provide",
"store",
"name",
"defined",
"in",
"{",
"@",
"code",
"materialized",
"}",
",",
"and",
"\"",
"-",
"changelog",
"\"",
"is",
"a",
"fixed",
"suffix",
"you",
"can",
"retrieve",
"all",
"generated",
"internal",
"topic",
"names",
"via",
"{",
"@",
"link",
"topology",
"#",
"describe",
"(",
")",
"}"
] |
[
"k",
"table",
"<",
"k",
",",
"v",
"out",
">",
"aggregate",
"(",
"final",
"initializer",
"<",
"v",
"out",
">",
"initializer",
",",
"final",
"named",
"named",
")",
";"
] |
[
"test",
"the",
"property",
"'",
"integer",
"item",
"'"
] |
[
"public",
"void",
"integer",
"item",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"integer",
"item",
"}"
] |
[
"removes",
"the",
"task",
"to",
"the",
"list",
"of",
"tasks",
"that",
"have",
"not",
"yet",
"finished",
"running"
] |
[
"public",
"static",
"void",
"remove",
"tracked",
"task",
"(",
"task",
"task",
")",
"{",
"if",
"(",
"!",
"system",
"utilities",
"is",
"in",
"testing",
"mode",
"(",
")",
")",
"{",
"return",
";",
"}",
"running",
"tasks",
"remove",
"(",
"task",
")",
";",
"for",
"(",
"tracked",
"task",
"listener",
"listener",
":",
"listeners",
")",
"{",
"listener",
"task",
"removed",
"(",
"task",
")",
";",
"}",
"}"
] |
[
"test",
"that",
"shares",
"are",
"computed",
"accurately",
"even",
"when",
"the",
"number",
"of",
"resources",
"is",
"very",
"large",
"test",
"adapted",
"to",
"accommodate",
"long",
"values",
"for",
"resources"
] |
[
"public",
"void",
"test",
"large",
"shares",
"(",
")",
"{",
"long",
"giga",
"=",
"1000l",
"*",
"1000l",
"*",
"1000l",
"*",
"4l",
";",
"scheds",
"add",
"(",
"new",
"fake",
"schedulable",
"(",
"0l",
",",
"giga",
")",
")",
";",
"scheds",
"add",
"(",
"new",
"fake",
"schedulable",
"(",
"0l",
",",
"giga",
")",
")",
";",
"scheds",
"add",
"(",
"new",
"fake",
"schedulable",
"(",
"0l",
",",
"giga",
")",
")",
";",
"scheds",
"add",
"(",
"new",
"fake",
"schedulable",
"(",
"0l",
",",
"giga",
")",
")",
";",
"compute",
"fair",
"shares",
"compute",
"shares",
"(",
"scheds",
",",
"resources",
"create",
"resource",
"(",
"4",
"*",
"giga",
")",
",",
"resource",
"information",
"memory",
"mb",
"get",
"name",
"(",
")",
")",
";",
"verify",
"memory",
"shares",
"(",
"giga",
",",
"giga",
",",
"giga",
",",
"giga",
")",
";",
"}"
] |
[
"test",
"the",
"producer",
"-",
"consumer",
"pattern",
"using",
"the",
"non",
"-",
"blocking",
"methods",
"&",
"waits",
"on",
"the",
"mailbox"
] |
[
"public",
"void",
"test",
"concurrent",
"put",
"take",
"non",
"blocking",
"and",
"wait",
"(",
")",
"throws",
"exception",
"{",
"test",
"put",
"take",
"(",
"(",
"mailbox",
"-",
">",
"{",
"optional",
"<",
"mail",
">",
"optional",
"mail",
"=",
"mailbox",
"try",
"take",
"(",
"default",
"priority",
")",
";",
"while",
"(",
"!",
"optional",
"mail",
"is",
"present",
"(",
")",
")",
"{",
"optional",
"mail",
"=",
"mailbox",
"try",
"take",
"(",
"default",
"priority",
")",
";",
"}",
"return",
"optional",
"mail",
"get",
"(",
")",
";",
"}",
")",
")",
";",
"}"
] |
[
"draws",
"a",
"rectangle",
"in",
"the",
"xy",
"plane",
"using",
"{",
"@",
"link",
"shape",
"type",
"#",
"line",
"}",
"or",
"{",
"@",
"link",
"shape",
"type",
"#",
"filled",
"}"
] |
[
"public",
"void",
"rect",
"(",
"float",
"x",
",",
"float",
"y",
",",
"float",
"width",
",",
"float",
"height",
")",
"{",
"check",
"(",
"shape",
"type",
"line",
",",
"shape",
"type",
"filled",
",",
"8",
")",
";",
"float",
"color",
"bits",
"=",
"color",
"to",
"float",
"bits",
"(",
")",
";",
"if",
"(",
"shape",
"type",
"=",
"=",
"shape",
"type",
"line",
")",
"{",
"renderer",
"color",
"(",
"color",
"bits",
")",
";",
"renderer",
"vertex",
"(",
"x",
",",
"y",
",",
"0",
")",
";",
"renderer",
"color",
"(",
"color",
"bits",
")",
";",
"renderer",
"vertex",
"(",
"x",
"+",
"width",
",",
"y",
",",
"0",
")",
";",
"renderer",
"color",
"(",
"color",
"bits",
")",
";",
"renderer",
"vertex",
"(",
"x",
"+",
"width",
",",
"y",
",",
"0",
")",
";",
"renderer",
"color",
"(",
"color",
"bits",
")",
";",
"renderer",
"vertex",
"(",
"x",
"+",
"width",
",",
"y",
"+",
"height",
",",
"0",
")",
";",
"renderer",
"color",
"(",
"color",
"bits",
")",
";",
"renderer",
"vertex",
"(",
"x",
"+",
"width",
",",
"y",
"+",
"height",
",",
"0",
")",
";",
"renderer",
"color",
"(",
"color",
"bits",
")",
";",
"renderer",
"vertex",
"(",
"x",
",",
"y",
"+",
"height",
",",
"0",
")",
";",
"renderer",
"color",
"(",
"color",
"bits",
")",
";",
"renderer",
"vertex",
"(",
"x",
",",
"y",
"+",
"height",
",",
"0",
")",
";",
"renderer",
"color",
"(",
"color",
"bits",
")",
";",
"renderer",
"vertex",
"(",
"x",
",",
"y",
",",
"0",
")",
";",
"}",
"else",
"{",
"renderer",
"color",
"(",
"color",
"bits",
")",
";",
"renderer",
"vertex",
"(",
"x",
",",
"y",
",",
"0",
")",
";",
"renderer",
"color",
"(",
"color",
"bits",
")",
";",
"renderer",
"vertex",
"(",
"x",
"+",
"width",
",",
"y",
",",
"0",
")",
";",
"renderer",
"color",
"(",
"color",
"bits",
")",
";",
"renderer",
"vertex",
"(",
"x",
"+",
"width",
",",
"y",
"+",
"height",
",",
"0",
")",
";",
"renderer",
"color",
"(",
"color",
"bits",
")",
";",
"renderer",
"vertex",
"(",
"x",
"+",
"width",
",",
"y",
"+",
"height",
",",
"0",
")",
";",
"renderer",
"color",
"(",
"color",
"bits",
")",
";",
"renderer",
"vertex",
"(",
"x",
",",
"y",
"+",
"height",
",",
"0",
")",
";",
"renderer",
"color",
"(",
"color",
"bits",
")",
";",
"renderer",
"vertex",
"(",
"x",
",",
"y",
",",
"0",
")",
";",
"}",
"}"
] |
[
"truncate",
"(",
"unshift",
")",
"this",
"pattern",
"block",
"by",
"removing",
"bytes",
"from",
"the",
"left"
] |
[
"public",
"assembly",
"pattern",
"block",
"truncate",
"(",
"int",
"amt",
")",
"{",
"if",
"(",
"amt",
"=",
"=",
"0",
")",
"{",
"return",
"this",
";",
"}",
"if",
"(",
"offset",
">",
"=",
"amt",
")",
"{",
"return",
"new",
"assembly",
"pattern",
"block",
"(",
"this",
"offset",
"-",
"amt",
",",
"mask",
",",
"vals",
")",
";",
"}",
"int",
"to",
"cut",
"=",
"amt",
"-",
"offset",
";",
"/",
"/",
"this",
"circumstance",
"seems",
"unsettling",
",",
"but",
"i",
"think",
"it",
"'",
"s",
"correct",
"if",
"(",
"to",
"cut",
">",
"=",
"this",
"mask",
"length",
")",
"{",
"return",
"assembly",
"pattern",
"block",
"nop",
"(",
")",
";",
"}",
"byte",
"[",
"]",
"new",
"mask",
"=",
"arrays",
"copy",
"of",
"range",
"(",
"this",
"mask",
",",
"to",
"cut",
",",
"this",
"mask",
"length",
")",
";",
"byte",
"[",
"]",
"new",
"vals",
"=",
"arrays",
"copy",
"of",
"range",
"(",
"this",
"vals",
",",
"to",
"cut",
",",
"this",
"vals",
"length",
")",
";",
"return",
"new",
"assembly",
"pattern",
"block",
"(",
"0",
",",
"new",
"mask",
",",
"new",
"vals",
")",
";",
"}"
] |
[
"set",
"the",
"xa",
"transaction",
"manager",
"to",
"use",
"for",
"wrapping",
"endpoint",
"invocations",
",",
"enlisting",
"the",
"endpoint",
"resource",
"in",
"each",
"such",
"transaction",
"the",
"passed",
"-",
"in",
"object",
"may",
"be",
"a",
"transaction",
"manager",
"which",
"implements",
"spring",
"'",
"s",
"{",
"@",
"link",
"org",
"springframework",
"transaction",
"jta",
"transaction",
"factory",
"}",
"interface",
",",
"or",
"a",
"plain",
"{",
"@",
"link",
"javax",
"transaction",
"transaction",
"manager",
"}",
"if",
"no",
"transaction",
"manager",
"is",
"specified",
",",
"the",
"endpoint",
"invocation",
"will",
"simply",
"not",
"be",
"wrapped",
"in",
"an",
"xa",
"transaction",
"check",
"out",
"your",
"resource",
"provider",
"'",
"s",
"activation",
"spec",
"documentation",
"for",
"local",
"transaction",
"options",
"of",
"your",
"particular",
"provider"
] |
[
"public",
"void",
"set",
"transaction",
"manager",
"(",
"object",
"transaction",
"manager",
")",
"{",
"if",
"(",
"transaction",
"manager",
"instanceof",
"transaction",
"factory",
")",
"{",
"this",
"transaction",
"factory",
"=",
"(",
"transaction",
"factory",
")",
"transaction",
"manager",
";",
"}",
"else",
"if",
"(",
"transaction",
"manager",
"instanceof",
"transaction",
"manager",
")",
"{",
"this",
"transaction",
"factory",
"=",
"new",
"simple",
"transaction",
"factory",
"(",
"(",
"transaction",
"manager",
")",
"transaction",
"manager",
")",
";",
"}",
"else",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"transaction",
"manager",
"[",
"\"",
"+",
"transaction",
"manager",
"+",
"\"",
"]",
"is",
"neither",
"a",
"[",
"org",
"springframework",
"transaction",
"jta",
"transaction",
"factory",
"}",
"nor",
"a",
"\"",
"+",
"\"",
"[",
"javax",
"transaction",
"transaction",
"manager",
"]",
"\"",
")",
";",
"}"
] |
[
"the",
"sink",
"node",
"making",
"the",
"request",
"<",
"code",
">",
"istio",
"mcp",
"v",
"1alpha",
"1",
"sink",
"node",
"sink",
"node",
"=",
"2",
";",
"<",
"code",
">"
] |
[
"public",
"boolean",
"has",
"sink",
"node",
"(",
")",
"{",
"return",
"sink",
"node",
"!",
"=",
"null",
";",
"}"
] |
[
"uploads",
"two",
"chunked",
"file",
"streams",
"for",
"different",
"jobs",
"into",
"the",
"server",
"via",
"the",
"{",
"@",
"link",
"blob",
"server",
"}",
"file",
"transfers",
"should",
"be",
"successful"
] |
[
"private",
"void",
"test",
"put",
"chunked",
"stream",
"successful",
"get",
"(",
"@",
"nullable",
"job",
"i",
"d",
"job",
"id",
"1",
",",
"@",
"nullable",
"job",
"i",
"d",
"job",
"id",
"2",
",",
"blob",
"key",
"blob",
"type",
"blob",
"type",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"configuration",
"config",
"=",
"new",
"configuration",
"(",
")",
";",
"config",
"set",
"string",
"(",
"blob",
"server",
"options",
"storage",
"directory",
",",
"temporary",
"folder",
"new",
"folder",
"(",
")",
"get",
"absolute",
"path",
"(",
")",
")",
";",
"try",
"(",
"blob",
"server",
"server",
"=",
"new",
"blob",
"server",
"(",
"config",
",",
"new",
"void",
"blob",
"store",
"(",
")",
")",
")",
"{",
"server",
"start",
"(",
")",
";",
"byte",
"[",
"]",
"data",
"=",
"new",
"byte",
"[",
"2000000",
"]",
";",
"rnd",
"next",
"bytes",
"(",
"data",
")",
";",
"byte",
"[",
"]",
"data",
"2",
"=",
"arrays",
"copy",
"of",
"range",
"(",
"data",
",",
"10",
",",
"54",
")",
";",
"/",
"/",
"put",
"data",
"for",
"job",
"id",
"1",
"and",
"verify",
"blob",
"key",
"key",
"1a",
"=",
"put",
"(",
"server",
",",
"job",
"id",
"1",
",",
"new",
"chunked",
"input",
"stream",
"(",
"data",
",",
"19",
")",
",",
"blob",
"type",
")",
";",
"assert",
"not",
"null",
"(",
"key",
"1a",
")",
";",
"/",
"/",
"second",
"upload",
"of",
"same",
"data",
"should",
"yield",
"a",
"different",
"blob",
"key",
"blob",
"key",
"key",
"1a",
"2",
"=",
"put",
"(",
"server",
",",
"job",
"id",
"1",
",",
"new",
"chunked",
"input",
"stream",
"(",
"data",
",",
"19",
")",
",",
"blob",
"type",
")",
";",
"assert",
"not",
"null",
"(",
"key",
"1a",
"2",
")",
";",
"verify",
"key",
"different",
"hash",
"equals",
"(",
"key",
"1a",
",",
"key",
"1a",
"2",
")",
";",
"blob",
"key",
"key",
"1b",
"=",
"put",
"(",
"server",
",",
"job",
"id",
"1",
",",
"new",
"chunked",
"input",
"stream",
"(",
"data",
"2",
",",
"19",
")",
",",
"blob",
"type",
")",
";",
"assert",
"not",
"null",
"(",
"key",
"1b",
")",
";",
"verify",
"contents",
"(",
"server",
",",
"job",
"id",
"1",
",",
"key",
"1a",
",",
"data",
")",
";",
"verify",
"contents",
"(",
"server",
",",
"job",
"id",
"1",
",",
"key",
"1a",
"2",
",",
"data",
")",
";",
"verify",
"contents",
"(",
"server",
",",
"job",
"id",
"1",
",",
"key",
"1b",
",",
"data",
"2",
")",
";",
"/",
"/",
"now",
"put",
"data",
"for",
"job",
"id",
"2",
"and",
"verify",
"that",
"both",
"are",
"ok",
"blob",
"key",
"key",
"2a",
"=",
"put",
"(",
"server",
",",
"job",
"id",
"2",
",",
"new",
"chunked",
"input",
"stream",
"(",
"data",
",",
"19",
")",
",",
"blob",
"type",
")",
";",
"assert",
"not",
"null",
"(",
"key",
"2a",
")",
";",
"verify",
"key",
"different",
"hash",
"equals",
"(",
"key",
"1a",
",",
"key",
"2a",
")",
";",
"blob",
"key",
"key",
"2b",
"=",
"put",
"(",
"server",
",",
"job",
"id",
"2",
",",
"new",
"chunked",
"input",
"stream",
"(",
"data",
"2",
",",
"19",
")",
",",
"blob",
"type",
")",
";",
"assert",
"not",
"null",
"(",
"key",
"2b",
")",
";",
"verify",
"key",
"different",
"hash",
"equals",
"(",
"key",
"1b",
",",
"key",
"2b",
")",
";",
"/",
"/",
"verify",
"the",
"accessibility",
"and",
"the",
"blob",
"contents",
"verify",
"contents",
"(",
"server",
",",
"job",
"id",
"2",
",",
"key",
"2a",
",",
"data",
")",
";",
"verify",
"contents",
"(",
"server",
",",
"job",
"id",
"2",
",",
"key",
"2b",
",",
"data",
"2",
")",
";",
"/",
"/",
"verify",
"the",
"accessibility",
"and",
"the",
"blob",
"contents",
"one",
"more",
"time",
"(",
"transient",
"b",
"l",
"o",
"bs",
"should",
"/",
"/",
"not",
"be",
"deleted",
"here",
")",
"verify",
"contents",
"(",
"server",
",",
"job",
"id",
"1",
",",
"key",
"1a",
",",
"data",
")",
";",
"verify",
"contents",
"(",
"server",
",",
"job",
"id",
"1",
",",
"key",
"1a",
"2",
",",
"data",
")",
";",
"verify",
"contents",
"(",
"server",
",",
"job",
"id",
"1",
",",
"key",
"1b",
",",
"data",
"2",
")",
";",
"verify",
"contents",
"(",
"server",
",",
"job",
"id",
"2",
",",
"key",
"2a",
",",
"data",
")",
";",
"verify",
"contents",
"(",
"server",
",",
"job",
"id",
"2",
",",
"key",
"2b",
",",
"data",
"2",
")",
";",
"}",
"}"
] |
[
"creates",
"a",
"server",
"builder",
"configured",
"with",
"the",
"given",
"{",
"@",
"link",
"socket",
"address",
"}"
] |
[
"public",
"static",
"netty",
"server",
"builder",
"for",
"address",
"(",
"socket",
"address",
"address",
",",
"server",
"credentials",
"creds",
")",
"{",
"protocol",
"negotiators",
"from",
"server",
"credentials",
"result",
"result",
"=",
"protocol",
"negotiators",
"from",
"(",
"creds",
")",
";",
"if",
"(",
"result",
"error",
"!",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"result",
"error",
")",
";",
"}",
"return",
"new",
"netty",
"server",
"builder",
"(",
"address",
",",
"result",
"negotiator",
")",
";",
"}"
] |
[
"compatible",
"with",
"older",
"version",
"logic",
",",
"in",
"version",
"1",
"2",
"1",
"and",
"before"
] |
[
"public",
"synchronized",
"void",
"on",
"receive",
"server",
"status",
"(",
"string",
"config",
"info",
")",
"{",
"loggers",
"srv",
"log",
"info",
"(",
"\"",
"receive",
"config",
"info",
":",
"{",
"}",
"\"",
",",
"config",
"info",
")",
";",
"string",
"[",
"]",
"configs",
"=",
"config",
"info",
"split",
"(",
"\"",
"\\",
"r",
"\\",
"n",
"\"",
")",
";",
"if",
"(",
"configs",
"length",
"=",
"=",
"0",
")",
"{",
"return",
";",
"}",
"for",
"(",
"string",
"config",
":",
"configs",
")",
"{",
"/",
"/",
"site",
":",
"ip",
":",
"last",
"report",
"time",
":",
"weight",
"string",
"[",
"]",
"params",
"=",
"config",
"split",
"(",
"\"",
"#",
"\"",
")",
";",
"if",
"(",
"params",
"length",
"<",
"=",
"3",
")",
"{",
"loggers",
"srv",
"log",
"warn",
"(",
"\"",
"received",
"malformed",
"distro",
"map",
"data",
":",
"{",
"}",
"\"",
",",
"config",
")",
";",
"continue",
";",
"}",
"string",
"[",
"]",
"info",
"=",
"i",
"p",
"util",
"split",
"i",
"p",
"port",
"str",
"(",
"params",
"[",
"1",
"]",
")",
";",
"member",
"server",
"=",
"optional",
"of",
"nullable",
"(",
"member",
"manager",
"find",
"(",
"params",
"[",
"1",
"]",
")",
")",
"or",
"else",
"(",
"member",
"builder",
"(",
")",
"ip",
"(",
"info",
"[",
"0",
"]",
")",
"state",
"(",
"node",
"state",
"up",
")",
"port",
"(",
"integer",
"parse",
"int",
"(",
"info",
"[",
"1",
"]",
")",
")",
"build",
"(",
")",
")",
";",
"server",
"set",
"extend",
"val",
"(",
"member",
"meta",
"data",
"constants",
"site",
"key",
",",
"params",
"[",
"0",
"]",
")",
";",
"server",
"set",
"extend",
"val",
"(",
"member",
"meta",
"data",
"constants",
"weight",
",",
"params",
"length",
"=",
"=",
"4",
"?",
"integer",
"parse",
"int",
"(",
"params",
"[",
"3",
"]",
")",
":",
"1",
")",
";",
"member",
"manager",
"update",
"(",
"server",
")",
";",
"if",
"(",
"!",
"contains",
"(",
"server",
"get",
"address",
"(",
")",
")",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"server",
":",
"\"",
"+",
"server",
"get",
"address",
"(",
")",
"+",
"\"",
"is",
"not",
"in",
"serverlist",
"\"",
")",
";",
"}",
"}",
"}"
] |
[
"generate",
"an",
"output",
"keyvalue",
"pair"
] |
[
"public",
"void",
"write",
"(",
"keyout",
"key",
",",
"valueout",
"value",
")",
"throws",
"i",
"o",
"exception",
",",
"interrupted",
"exception",
";"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.