docstring_tokens
list | code_tokens
list |
|---|---|
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
] |
[
"private",
"string",
"to",
"indented",
"string",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"returns",
"the",
"top",
"-",
"level",
"location",
"of",
"the",
"classes",
"and",
"dependencies",
"required",
"by",
"the",
"plugin",
"that",
"is",
"loaded",
"by",
"this",
"classloader"
] |
[
"public",
"string",
"location",
"(",
")",
"{",
"return",
"plugin",
"location",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"forcibly",
"terminates",
"the",
"currently",
"running",
"java",
"virtual",
"machine"
] |
[
"public",
"static",
"void",
"halt",
"(",
"int",
"status",
",",
"string",
"message",
")",
"throws",
"halt",
"exception",
"{",
"halt",
"(",
"new",
"halt",
"exception",
"(",
"status",
",",
"message",
")",
")",
";",
"}"
] |
[
"provide",
"a",
"default",
"port",
"if",
"the",
"parsed",
"string",
"contained",
"only",
"a",
"host",
"you",
"can",
"chain",
"this",
"after",
"{",
"@",
"link",
"#",
"from",
"string",
"(",
"string",
")",
"}",
"to",
"include",
"a",
"port",
"in",
"case",
"the",
"port",
"was",
"omitted",
"from",
"the",
"input",
"string",
"if",
"a",
"port",
"was",
"already",
"provided",
",",
"then",
"this",
"method",
"is",
"a",
"no",
"-",
"op"
] |
[
"public",
"host",
"address",
"with",
"default",
"port",
"(",
"int",
"default",
"port",
")",
"{",
"if",
"(",
"!",
"is",
"valid",
"port",
"(",
"default",
"port",
")",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"port",
"number",
"out",
"of",
"range",
":",
"\"",
"+",
"default",
"port",
")",
";",
"}",
"if",
"(",
"has",
"port",
"(",
")",
"|",
"|",
"port",
"=",
"=",
"default",
"port",
")",
"{",
"return",
"this",
";",
"}",
"return",
"new",
"host",
"address",
"(",
"host",
",",
"default",
"port",
")",
";",
"}"
] |
[
"build",
"the",
"underlying",
"aspect",
"j",
"pointcut",
"expression"
] |
[
"private",
"pointcut",
"expression",
"build",
"pointcut",
"expression",
"(",
"@",
"nullable",
"class",
"loader",
"class",
"loader",
")",
"{",
"pointcut",
"parser",
"parser",
"=",
"initialize",
"pointcut",
"parser",
"(",
"class",
"loader",
")",
";",
"pointcut",
"parameter",
"[",
"]",
"pointcut",
"parameters",
"=",
"new",
"pointcut",
"parameter",
"[",
"this",
"pointcut",
"parameter",
"names",
"length",
"]",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"pointcut",
"parameters",
"length",
";",
"i",
"+",
"+",
")",
"{",
"pointcut",
"parameters",
"[",
"i",
"]",
"=",
"parser",
"create",
"pointcut",
"parameter",
"(",
"this",
"pointcut",
"parameter",
"names",
"[",
"i",
"]",
",",
"this",
"pointcut",
"parameter",
"types",
"[",
"i",
"]",
")",
";",
"}",
"return",
"parser",
"parse",
"pointcut",
"expression",
"(",
"replace",
"boolean",
"operators",
"(",
"resolve",
"expression",
"(",
")",
")",
",",
"this",
"pointcut",
"declaration",
"scope",
",",
"pointcut",
"parameters",
")",
";",
"}"
] |
[
"set",
"the",
"byte",
"offset",
"of",
"where",
"this",
"component",
"begins",
"in",
"its",
"immediate",
"parent",
"data",
"type"
] |
[
"void",
"set",
"offset",
"(",
"int",
"offset",
")",
"{",
"this",
"offset",
"=",
"offset",
";",
"}"
] |
[
"replace",
"all",
"current",
"parameters",
"with",
"the",
"given",
"list",
"of",
"parameters",
"the",
"{",
"@",
"link",
"variable",
"utilities",
"#",
"check",
"variable",
"conflict",
"(",
"function",
",",
"variable",
",",
"variable",
"storage",
",",
"boolean",
")",
"}",
"method",
"may",
"be",
"used",
"to",
"check",
"and",
"remove",
"conflicting",
"variables",
"which",
"already",
"exist",
"in",
"the",
"function"
] |
[
"public",
"void",
"replace",
"parameters",
"(",
"list",
"<",
"?",
"extends",
"variable",
">",
"params",
",",
"function",
"update",
"type",
"update",
"type",
",",
"boolean",
"force",
",",
"source",
"type",
"source",
")",
"throws",
"duplicate",
"name",
"exception",
",",
"invalid",
"input",
"exception",
";"
] |
[
"test",
"the",
"property",
"'",
"bar",
"'"
] |
[
"public",
"void",
"bar",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"bar",
"}"
] |
[
"returns",
"an",
"unmodifiable",
"view",
"of",
"the",
"dwo",
"files",
"set"
] |
[
"public",
"immutable",
"list",
"<",
"artifact",
">",
"get",
"dwo",
"files",
"(",
")",
"{",
"return",
"dwo",
"files",
";",
"}"
] |
[
"set",
"threshold",
"when",
"to",
"flush",
"buffered",
"request",
"based",
"on",
"the",
"memory",
"byte",
"size",
"of",
"rows",
"currently",
"added",
"default",
"to",
"<",
"code",
">",
"2mb",
"<",
"code",
">",
"optional"
] |
[
"public",
"h",
"base",
"write",
"buffer",
"flush",
"max",
"size",
"(",
"string",
"max",
"size",
")",
"{",
"properties",
"put",
"memory",
"size",
"(",
"connector",
"write",
"buffer",
"flush",
"max",
"size",
",",
"memory",
"size",
"parse",
"(",
"max",
"size",
",",
"memory",
"size",
"memory",
"unit",
"bytes",
")",
")",
";",
"return",
"this",
";",
"}"
] |
[
"unsafely",
"returns",
"a",
"copy",
"of",
"the",
"given",
"entry"
] |
[
"e",
"copy",
"for",
"testing",
"(",
"internal",
"entry",
"<",
"k",
",",
"v",
",",
"?",
">",
"entry",
",",
"@",
"nullable",
"internal",
"entry",
"<",
"k",
",",
"v",
",",
"?",
">",
"new",
"next",
")",
"{",
"return",
"this",
"map",
"entry",
"helper",
"copy",
"(",
"self",
"(",
")",
",",
"cast",
"for",
"testing",
"(",
"entry",
")",
",",
"cast",
"for",
"testing",
"(",
"new",
"next",
")",
")",
";",
"}"
] |
[
"：",
"windos",
"2",
"0",
"0",
"0",
"|",
"linliangyi",
"2",
"0",
"0",
"5",
"@",
"gmail",
"com"
] |
[
"private",
"boolean",
"process",
"mix",
"letter",
"(",
"analyze",
"context",
"context",
")",
"{",
"boolean",
"need",
"lock",
"=",
"false",
";",
"if",
"(",
"this",
"start",
"=",
"=",
"-",
"1",
")",
"{",
"/",
"/",
"if",
"(",
"character",
"util",
"char",
"arabic",
"=",
"=",
"context",
"get",
"current",
"char",
"type",
"(",
")",
"|",
"|",
"character",
"util",
"char",
"english",
"=",
"=",
"context",
"get",
"current",
"char",
"type",
"(",
")",
")",
"{",
"/",
"/",
",",
"this",
"start",
"=",
"context",
"get",
"cursor",
"(",
")",
";",
"this",
"end",
"=",
"start",
";",
"}",
"}",
"else",
"{",
"/",
"/",
"if",
"(",
"character",
"util",
"char",
"arabic",
"=",
"=",
"context",
"get",
"current",
"char",
"type",
"(",
")",
"|",
"|",
"character",
"util",
"char",
"english",
"=",
"=",
"context",
"get",
"current",
"char",
"type",
"(",
")",
")",
"{",
"/",
"/",
"this",
"end",
"=",
"context",
"get",
"cursor",
"(",
")",
";",
"}",
"else",
"if",
"(",
"character",
"util",
"char",
"useless",
"=",
"=",
"context",
"get",
"current",
"char",
"type",
"(",
")",
"&",
"&",
"this",
"is",
"letter",
"connector",
"(",
"context",
"get",
"current",
"char",
"(",
")",
")",
")",
"{",
"/",
"/",
"this",
"end",
"=",
"context",
"get",
"cursor",
"(",
")",
";",
"}",
"else",
"{",
"/",
"/",
"，",
"lexeme",
"new",
"lexeme",
"=",
"new",
"lexeme",
"(",
"context",
"get",
"buffer",
"offset",
"(",
")",
",",
"this",
"start",
",",
"this",
"end",
"-",
"this",
"start",
"+",
"1",
",",
"lexeme",
"type",
"letter",
")",
";",
"context",
"add",
"lexeme",
"(",
"new",
"lexeme",
")",
";",
"this",
"start",
"=",
"-",
"1",
";",
"this",
"end",
"=",
"-",
"1",
";",
"}",
"}",
"/",
"/",
"if",
"(",
"context",
"is",
"buffer",
"consumed",
"(",
")",
"&",
"&",
"(",
"this",
"start",
"!",
"=",
"-",
"1",
"&",
"&",
"this",
"end",
"!",
"=",
"-",
"1",
")",
")",
"{",
"/",
"/",
"，",
"lexeme",
"new",
"lexeme",
"=",
"new",
"lexeme",
"(",
"context",
"get",
"buffer",
"offset",
"(",
")",
",",
"this",
"start",
",",
"this",
"end",
"-",
"this",
"start",
"+",
"1",
",",
"lexeme",
"type",
"letter",
")",
";",
"context",
"add",
"lexeme",
"(",
"new",
"lexeme",
")",
";",
"this",
"start",
"=",
"-",
"1",
";",
"this",
"end",
"=",
"-",
"1",
";",
"}",
"/",
"/",
"if",
"(",
"this",
"start",
"=",
"=",
"-",
"1",
"&",
"&",
"this",
"end",
"=",
"=",
"-",
"1",
")",
"{",
"/",
"/",
"need",
"lock",
"=",
"false",
";",
"}",
"else",
"{",
"need",
"lock",
"=",
"true",
";",
"}",
"return",
"need",
"lock",
";",
"}"
] |
[
"substitutes",
"attribute",
"-",
"placeholders",
"in",
"a",
"template",
"string",
",",
"producing",
"all",
"possible",
"combinations"
] |
[
"public",
"static",
"immutable",
"list",
"<",
"string",
">",
"substitute",
"placeholder",
"into",
"template",
"(",
"string",
"template",
",",
"attribute",
"map",
"rule",
",",
"attribute",
"value",
"getter",
"attribute",
"getter",
")",
"{",
"/",
"/",
"parse",
"the",
"template",
"to",
"get",
"the",
"attribute",
"names",
"and",
"format",
"string",
"parsed",
"template",
"parsed",
"template",
"=",
"parsed",
"template",
"parse",
"(",
"template",
")",
";",
"/",
"/",
"return",
"the",
"substituted",
"strings",
"return",
"parsed",
"template",
"substitute",
"attributes",
"(",
"rule",
",",
"attribute",
"getter",
")",
";",
"}"
] |
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
] |
[
"private",
"string",
"to",
"indented",
"string",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"get",
"user",
"account"
] |
[
"public",
"user",
"account",
"get",
"(",
"string",
"user",
"id",
")",
"{",
"if",
"(",
"cache",
"contains",
"key",
"(",
"user",
"id",
")",
")",
"{",
"var",
"node",
"=",
"cache",
"get",
"(",
"user",
"id",
")",
";",
"remove",
"(",
"node",
")",
";",
"set",
"head",
"(",
"node",
")",
";",
"return",
"node",
"user",
"account",
";",
"}",
"return",
"null",
";",
"}"
] |
[
"the",
"configuration",
"object",
"is",
"shared",
"by",
"both",
"kms",
"client",
"and",
"server",
"in",
"unit",
"tests",
"because",
"ugi",
"getssets",
"it",
"to",
"a",
"static",
"variable",
"as",
"a",
"workaround",
",",
"make",
"sure",
"the",
"client",
"configurations",
"are",
"copied",
"to",
"server",
"so",
"that",
"client",
"can",
"read",
"them"
] |
[
"protected",
"configuration",
"create",
"base",
"k",
"m",
"s",
"conf",
"(",
"file",
"key",
"store",
"dir",
",",
"configuration",
"conf",
")",
"throws",
"exception",
"{",
"configuration",
"new",
"conf",
";",
"if",
"(",
"conf",
"=",
"=",
"null",
")",
"{",
"new",
"conf",
"=",
"new",
"configuration",
"(",
"false",
")",
";",
"}",
"else",
"{",
"new",
"conf",
"=",
"new",
"configuration",
"(",
"conf",
")",
";",
"}",
"new",
"conf",
"set",
"(",
"k",
"m",
"s",
"configuration",
"key",
"provider",
"uri",
",",
"\"",
"jceks",
":",
"/",
"/",
"file",
"@",
"\"",
"+",
"new",
"path",
"(",
"key",
"store",
"dir",
"get",
"absolute",
"path",
"(",
")",
",",
"\"",
"kms",
"keystore",
"\"",
")",
"to",
"uri",
"(",
")",
")",
";",
"new",
"conf",
"set",
"(",
"\"",
"hadoop",
"kms",
"authentication",
"type",
"\"",
",",
"\"",
"simple",
"\"",
")",
";",
"return",
"new",
"conf",
";",
"}"
] |
[
"this",
"method",
"is",
"a",
"default",
"implementation",
"that",
"uses",
"java",
"serialization",
"and",
"it",
"is",
"discouraged",
"all",
"implementation",
"should",
"provide",
"a",
"more",
"specific",
"set",
"of",
"properties"
] |
[
"public",
"map",
"<",
"string",
",",
"string",
">",
"to",
"properties",
"(",
")",
"{",
"map",
"<",
"string",
",",
"string",
">",
"properties",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"properties",
"put",
"(",
"rowtime",
"rowtime",
"watermarks",
"type",
",",
"rowtime",
"rowtime",
"watermarks",
"type",
"value",
"custom",
")",
";",
"properties",
"put",
"(",
"rowtime",
"rowtime",
"watermarks",
"class",
",",
"this",
"get",
"class",
"(",
")",
"get",
"name",
"(",
")",
")",
";",
"properties",
"put",
"(",
"rowtime",
"rowtime",
"watermarks",
"serialized",
",",
"encoding",
"utils",
"encode",
"object",
"to",
"string",
"(",
"this",
")",
")",
";",
"return",
"properties",
";",
"}"
] |
[
"returns",
"the",
"empty",
"array"
] |
[
"public",
"static",
"immutable",
"double",
"array",
"of",
"(",
")",
"{",
"return",
"empty",
";",
"}"
] |
[
"remove",
"snapshots",
"and",
"remove",
"any",
"indices",
"that",
"no",
"longer",
"exist",
"in",
"the",
"repository",
"due",
"to",
"the",
"deletion",
"of",
"the",
"snapshots"
] |
[
"public",
"repository",
"data",
"remove",
"snapshots",
"(",
"final",
"collection",
"<",
"snapshot",
"id",
">",
"snapshots",
",",
"final",
"shard",
"generations",
"updated",
"shard",
"generations",
")",
"{",
"map",
"<",
"string",
",",
"snapshot",
"id",
">",
"new",
"snapshot",
"ids",
"=",
"snapshot",
"ids",
"values",
"(",
")",
"stream",
"(",
")",
"filter",
"(",
"predicate",
"not",
"(",
"snapshots",
":",
":",
"contains",
")",
")",
"collect",
"(",
"collectors",
"to",
"map",
"(",
"snapshot",
"id",
":",
":",
"get",
"u",
"u",
"i",
"d",
",",
"function",
"identity",
"(",
")",
")",
")",
";",
"if",
"(",
"new",
"snapshot",
"ids",
"size",
"(",
")",
"!",
"=",
"snapshot",
"ids",
"size",
"(",
")",
"-",
"snapshots",
"size",
"(",
")",
")",
"{",
"final",
"collection",
"<",
"snapshot",
"id",
">",
"not",
"found",
"=",
"new",
"hash",
"set",
"<",
">",
"(",
"snapshots",
")",
";",
"not",
"found",
"remove",
"all",
"(",
"snapshot",
"ids",
"values",
"(",
")",
")",
";",
"throw",
"new",
"resource",
"not",
"found",
"exception",
"(",
"\"",
"attempting",
"to",
"remove",
"non",
"-",
"existent",
"snapshots",
"{",
"}",
"from",
"repository",
"data",
"\"",
",",
"not",
"found",
")",
";",
"}",
"map",
"<",
"string",
",",
"snapshot",
"state",
">",
"new",
"snapshot",
"states",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
"snapshot",
"states",
")",
";",
"final",
"map",
"<",
"string",
",",
"version",
">",
"new",
"snapshot",
"versions",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
"snapshot",
"versions",
")",
";",
"for",
"(",
"snapshot",
"id",
"snapshot",
"id",
":",
"snapshots",
")",
"{",
"new",
"snapshot",
"states",
"remove",
"(",
"snapshot",
"id",
"get",
"u",
"u",
"i",
"d",
"(",
")",
")",
";",
"new",
"snapshot",
"versions",
"remove",
"(",
"snapshot",
"id",
"get",
"u",
"u",
"i",
"d",
"(",
")",
")",
";",
"}",
"map",
"<",
"index",
"id",
",",
"list",
"<",
"snapshot",
"id",
">",
">",
"index",
"snapshots",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"for",
"(",
"final",
"index",
"id",
"index",
"id",
":",
"indices",
"values",
"(",
")",
")",
"{",
"list",
"<",
"snapshot",
"id",
">",
"snapshot",
"ids",
"=",
"this",
"index",
"snapshots",
"get",
"(",
"index",
"id",
")",
";",
"assert",
"snapshot",
"ids",
"!",
"=",
"null",
";",
"list",
"<",
"snapshot",
"id",
">",
"remaining",
"=",
"new",
"array",
"list",
"<",
">",
"(",
"snapshot",
"ids",
")",
";",
"if",
"(",
"remaining",
"remove",
"all",
"(",
"snapshots",
")",
")",
"{",
"remaining",
"=",
"collections",
"unmodifiable",
"list",
"(",
"remaining",
")",
";",
"}",
"else",
"{",
"remaining",
"=",
"snapshot",
"ids",
";",
"}",
"if",
"(",
"remaining",
"is",
"empty",
"(",
")",
"=",
"=",
"false",
")",
"{",
"index",
"snapshots",
"put",
"(",
"index",
"id",
",",
"remaining",
")",
";",
"}",
"}",
"return",
"new",
"repository",
"data",
"(",
"gen",
"id",
",",
"new",
"snapshot",
"ids",
",",
"new",
"snapshot",
"states",
",",
"new",
"snapshot",
"versions",
",",
"index",
"snapshots",
",",
"shard",
"generations",
"builder",
"(",
")",
"put",
"all",
"(",
"shard",
"generations",
")",
"put",
"all",
"(",
"updated",
"shard",
"generations",
")",
"retain",
"indices",
"and",
"prune",
"deletes",
"(",
"index",
"snapshots",
"key",
"set",
"(",
")",
")",
"build",
"(",
")",
",",
"index",
"meta",
"data",
"generations",
"with",
"removed",
"snapshots",
"(",
"snapshots",
")",
")",
";",
"}"
] |
[
"set",
"the",
"instantiation",
"strategy",
"to",
"use",
"for",
"creating",
"bean",
"instances",
"default",
"is",
"cglib",
"subclassing",
"instantiation",
"strategy"
] |
[
"public",
"void",
"set",
"instantiation",
"strategy",
"(",
"instantiation",
"strategy",
"instantiation",
"strategy",
")",
"{",
"this",
"instantiation",
"strategy",
"=",
"instantiation",
"strategy",
";",
"}"
] |
[
"closes",
"the",
"stream",
"owned",
"resources",
"are",
"released",
"back",
"to",
"the",
"pool",
"it",
"is",
"not",
"allowed",
"to",
"call",
"to",
"byte",
"buffer",
"after",
"call",
"to",
"this",
"method"
] |
[
"public",
"void",
"close",
"(",
")",
"{",
"closeable",
"reference",
"close",
"safely",
"(",
"m",
"buf",
"ref",
")",
";",
"m",
"buf",
"ref",
"=",
"null",
";",
"m",
"count",
"=",
"-",
"1",
";",
"super",
"close",
"(",
")",
";",
"}"
] |
[
"read",
"string",
"from",
"table",
"at",
"specified",
"relative",
"table",
"offset"
] |
[
"public",
"string",
"read",
"string",
"(",
"binary",
"reader",
"reader",
",",
"long",
"string",
"offset",
")",
"{",
"if",
"(",
"file",
"offset",
"<",
"0",
")",
"{",
"return",
"null",
";",
"}",
"try",
"{",
"if",
"(",
"string",
"offset",
">",
"=",
"length",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"\"",
"string",
"read",
"beyond",
"table",
"bounds",
"\"",
")",
";",
"}",
"return",
"reader",
"read",
"ascii",
"string",
"(",
"file",
"offset",
"+",
"string",
"offset",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"msg",
"error",
"(",
"this",
",",
"\"",
"failed",
"to",
"read",
"elf",
"string",
"at",
"offset",
"0x",
"\"",
"+",
"long",
"to",
"hex",
"string",
"(",
"string",
"offset",
")",
"+",
"\"",
"within",
"string",
"table",
"at",
"offset",
"0x",
"\"",
"+",
"long",
"to",
"hex",
"string",
"(",
"file",
"offset",
")",
")",
";",
"}",
"return",
"null",
";",
"}"
] |
[
"additional",
"data",
"to",
"pass",
"to",
"server"
] |
[
"public",
"string",
"get",
"additional",
"metadata",
"(",
")",
"{",
"return",
"additional",
"metadata",
";",
"}"
] |
[
"create",
"a",
"new",
"saml",
"object"
] |
[
"public",
"static",
"<",
"t",
"extends",
"s",
"a",
"m",
"l",
"object",
">",
"t",
"new",
"saml",
"object",
"(",
"final",
"class",
"<",
"t",
">",
"object",
"type",
")",
"{",
"val",
"q",
"name",
"=",
"get",
"saml",
"object",
"q",
"name",
"(",
"object",
"type",
")",
";",
"return",
"new",
"saml",
"object",
"(",
"object",
"type",
",",
"q",
"name",
")",
";",
"}"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"set",
"the",
"environment",
"properties",
"used",
"to",
"construct",
"the",
"{",
"@",
"code",
"j",
"m",
"x",
"connector",
"server",
"}",
"as",
"{",
"@",
"code",
"java",
"util",
"properties",
"}",
"(",
"string",
"keyvalue",
"pairs",
")"
] |
[
"public",
"void",
"set",
"environment",
"(",
"@",
"nullable",
"properties",
"environment",
")",
"{",
"collection",
"utils",
"merge",
"properties",
"into",
"map",
"(",
"environment",
",",
"this",
"environment",
")",
";",
"}"
] |
[
"returns",
"a",
"log",
"of",
"unknown",
"primitive",
"type",
"record",
"numbers"
] |
[
"private",
"string",
"get",
"unknown",
"primitives",
"log",
"(",
")",
"{",
"string",
"builder",
"builder",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"delimiter",
"state",
"ds",
"=",
"new",
"delimiter",
"state",
"(",
"\"",
"unknown",
"primitive",
"record",
"numbers",
"seen",
":",
"\"",
",",
"\"",
",",
"\"",
")",
";",
"/",
"*",
"*",
"sort",
"these",
"before",
"printing",
"to",
"avoid",
"sorting",
"performance",
"hit",
"when",
"logging",
"is",
"not",
"used",
"*",
"/",
"set",
"<",
"integer",
">",
"sorted",
"set",
"=",
"new",
"tree",
"set",
"<",
">",
"(",
"unknown",
"primitives",
")",
";",
"for",
"(",
"integer",
"val",
":",
"sorted",
"set",
")",
"{",
"builder",
"append",
"(",
"ds",
"out",
"(",
"true",
",",
"string",
"format",
"(",
"\"",
"0x",
"%",
"04x",
"\"",
",",
"val",
")",
")",
")",
";",
"}",
"return",
"builder",
"to",
"string",
"(",
")",
";",
"}"
] |
[
"create",
"a",
"pipeline",
"that",
"allows",
"documents",
"for",
"different",
"template",
"versions",
"to",
"be",
"upgraded",
"the",
"expectation",
"is",
"that",
"you",
"will",
"call",
"either",
"{",
"@",
"link",
"strings",
"#",
"to",
"string",
"(",
"x",
"content",
"builder",
")",
"}",
"or",
"{",
"@",
"link",
"bytes",
"reference",
"#",
"bytes",
"(",
"x",
"content",
"builder",
")",
"}",
"}"
] |
[
"public",
"static",
"x",
"content",
"builder",
"load",
"pipeline",
"(",
"final",
"string",
"id",
",",
"final",
"x",
"content",
"type",
"type",
")",
"{",
"switch",
"(",
"id",
")",
"{",
"case",
"template",
"version",
":",
"return",
"empty",
"pipeline",
"(",
"type",
")",
";",
"case",
"old",
"template",
"version",
":",
"return",
"pipeline",
"for",
"api",
"version",
"6",
"(",
"type",
")",
";",
"}",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"unrecognized",
"pipeline",
"api",
"version",
"[",
"\"",
"+",
"id",
"+",
"\"",
"]",
"\"",
")",
";",
"}"
] |
[
"gets",
"the",
"parameter",
"value"
] |
[
"public",
"object",
"get",
"value",
"(",
")",
"{",
"return",
"value",
";",
"}"
] |
[
"escapes",
"identifier",
"to",
"use",
"it",
"in",
"sql",
"statements",
"with",
"backticks",
",",
"eg",
"select",
"\"",
"identifier",
"\"",
"from",
"ref",
":",
"https",
":",
"www",
"sqlite",
"orgdrafttokenreq",
"html",
"h41130",
"spec",
"is",
"similar",
"to",
"my",
"s",
"q",
"l"
] |
[
"public",
"string",
"escape",
"quoted",
"identifier",
"(",
"string",
"identifier",
")",
"{",
"/",
"/",
"ascii",
":",
"[",
"0",
"-",
"9",
",",
"a",
"-",
"z",
",",
"a",
"-",
"z",
"$",
"]",
"(",
"basic",
"latin",
"letters",
",",
"digits",
"0",
"-",
"9",
",",
"dollar",
",",
"underscore",
")",
"extended",
":",
"u",
"+",
"0080",
"u",
"+",
"ffff",
"/",
"/",
"ascii",
"nul",
"(",
"u",
"+",
"0000",
")",
"and",
"supplementary",
"characters",
"(",
"u",
"+",
"10000",
"and",
"higher",
")",
"are",
"not",
"permitted",
"in",
"quoted",
"or",
"unquoted",
"identifiers",
"/",
"/",
"this",
"does",
"in",
"fact",
"matches",
"against",
">",
"\\",
"x",
"f",
"f",
"f",
"f",
"and",
"against",
"^",
"\\",
"x",
"0",
"0",
"0",
"0",
"works",
"only",
"on",
"java",
"7",
"+",
"pattern",
"regexp",
"=",
"pattern",
"compile",
"(",
"\"",
"[",
"^",
"0",
"-",
"9a",
"-",
"z",
"a",
"-",
"z",
"$",
"\\",
"\\",
"x",
"0",
"0",
"8",
"0",
"-",
"\\",
"\\",
"x",
"f",
"f",
"f",
"f",
"]",
"\"",
")",
";",
"matcher",
"matcher",
"=",
"regexp",
"matcher",
"(",
"identifier",
")",
";",
"if",
"(",
"matcher",
"find",
"(",
")",
")",
"{",
"logger",
"warn",
"(",
"\"",
"identifier",
"'",
"\"",
"+",
"identifier",
"+",
"\"",
"'",
"contains",
"unsafe",
"characters",
"out",
"of",
"[",
"0",
"-",
"9",
",",
"a",
"-",
"z",
",",
"a",
"-",
"z",
"$",
"]",
"and",
"u",
"+",
"0080",
"u",
"+",
"ffff",
"range",
"\"",
")",
";",
"identifier",
"=",
"identifier",
"replace",
"all",
"(",
"\"",
"[",
"^",
"0",
"-",
"9a",
"-",
"z",
"a",
"-",
"z",
"$",
"\\",
"\\",
"x",
"0",
"0",
"8",
"0",
"-",
"\\",
"\\",
"x",
"f",
"f",
"f",
"f",
"]",
"\"",
",",
"\"",
"\"",
")",
";",
"}",
"return",
"identifier",
";",
"}"
] |
[
"returns",
"an",
"immutable",
"bimap",
"containing",
"the",
"same",
"entries",
"as",
"{",
"@",
"code",
"map",
"}",
"if",
"{",
"@",
"code",
"map",
"}",
"somehow",
"contains",
"entries",
"with",
"duplicate",
"keys",
"(",
"for",
"example",
",",
"if",
"it",
"is",
"a",
"{",
"@",
"code",
"sorted",
"map",
"}",
"whose",
"comparator",
"is",
"not",
"consistent",
"with",
"equals",
")",
",",
"the",
"results",
"of",
"this",
"method",
"are",
"undefined",
"the",
"returned",
"{",
"@",
"code",
"bi",
"map",
"}",
"iterates",
"over",
"entries",
"in",
"the",
"same",
"order",
"as",
"the",
"{",
"@",
"code",
"entry",
"set",
"}",
"of",
"the",
"original",
"map",
"despite",
"the",
"method",
"name",
",",
"this",
"method",
"attempts",
"to",
"avoid",
"actually",
"copying",
"the",
"data",
"when",
"it",
"is",
"safe",
"to",
"do",
"so",
"the",
"exact",
"circumstances",
"under",
"which",
"a",
"copy",
"will",
"or",
"will",
"not",
"be",
"performed",
"are",
"undocumented",
"and",
"subject",
"to",
"change"
] |
[
"public",
"static",
"<",
"k",
",",
"v",
">",
"immutable",
"bi",
"map",
"<",
"k",
",",
"v",
">",
"copy",
"of",
"(",
"map",
"<",
"?",
"extends",
"k",
",",
"?",
"extends",
"v",
">",
"map",
")",
"{",
"if",
"(",
"map",
"instanceof",
"immutable",
"bi",
"map",
")",
"{",
"@",
"suppress",
"warnings",
"(",
"\"",
"unchecked",
"\"",
")",
"/",
"/",
"safe",
"since",
"map",
"is",
"not",
"writable",
"immutable",
"bi",
"map",
"<",
"k",
",",
"v",
">",
"bimap",
"=",
"(",
"immutable",
"bi",
"map",
"<",
"k",
",",
"v",
">",
")",
"map",
";",
"/",
"/",
"todo",
"(",
"lowasser",
")",
":",
"if",
"we",
"need",
"to",
"make",
"a",
"copy",
"of",
"a",
"bi",
"map",
"because",
"the",
"/",
"/",
"forward",
"map",
"is",
"a",
"view",
",",
"don",
"'",
"t",
"make",
"a",
"copy",
"of",
"the",
"non",
"-",
"view",
"delegate",
"map",
"if",
"(",
"!",
"bimap",
"is",
"partial",
"view",
"(",
")",
")",
"{",
"return",
"bimap",
";",
"}",
"}",
"return",
"copy",
"of",
"(",
"map",
"entry",
"set",
"(",
")",
")",
";",
"}"
] |
[
"print",
"information",
"about",
"the",
"connection"
] |
[
"public",
"synchronized",
"void",
"dump",
"connection",
"info",
"(",
"print",
"writer",
"pwriter",
",",
"boolean",
"brief",
")",
"{",
"pwriter",
"print",
"(",
"\"",
"\"",
")",
";",
"pwriter",
"print",
"(",
"get",
"remote",
"socket",
"address",
"(",
")",
")",
";",
"pwriter",
"print",
"(",
"\"",
"[",
"\"",
")",
";",
"int",
"interest",
"ops",
"=",
"get",
"interest",
"ops",
"(",
")",
";",
"pwriter",
"print",
"(",
"interest",
"ops",
"=",
"=",
"0",
"?",
"\"",
"0",
"\"",
":",
"integer",
"to",
"hex",
"string",
"(",
"interest",
"ops",
")",
")",
";",
"pwriter",
"print",
"(",
"\"",
"]",
"(",
"queued",
"=",
"\"",
")",
";",
"pwriter",
"print",
"(",
"get",
"outstanding",
"requests",
"(",
")",
")",
";",
"pwriter",
"print",
"(",
"\"",
",",
"recved",
"=",
"\"",
")",
";",
"pwriter",
"print",
"(",
"get",
"packets",
"received",
"(",
")",
")",
";",
"pwriter",
"print",
"(",
"\"",
",",
"sent",
"=",
"\"",
")",
";",
"pwriter",
"print",
"(",
"get",
"packets",
"sent",
"(",
")",
")",
";",
"if",
"(",
"!",
"brief",
")",
"{",
"long",
"session",
"id",
"=",
"get",
"session",
"id",
"(",
")",
";",
"if",
"(",
"session",
"id",
"!",
"=",
"0",
")",
"{",
"pwriter",
"print",
"(",
"\"",
",",
"sid",
"=",
"0x",
"\"",
")",
";",
"pwriter",
"print",
"(",
"long",
"to",
"hex",
"string",
"(",
"session",
"id",
")",
")",
";",
"pwriter",
"print",
"(",
"\"",
",",
"lop",
"=",
"\"",
")",
";",
"pwriter",
"print",
"(",
"get",
"last",
"operation",
"(",
")",
")",
";",
"pwriter",
"print",
"(",
"\"",
",",
"est",
"=",
"\"",
")",
";",
"pwriter",
"print",
"(",
"get",
"established",
"(",
")",
"get",
"time",
"(",
")",
")",
";",
"pwriter",
"print",
"(",
"\"",
",",
"to",
"=",
"\"",
")",
";",
"pwriter",
"print",
"(",
"get",
"session",
"timeout",
"(",
")",
")",
";",
"long",
"last",
"cxid",
"=",
"get",
"last",
"cxid",
"(",
")",
";",
"if",
"(",
"last",
"cxid",
">",
"=",
"0",
")",
"{",
"pwriter",
"print",
"(",
"\"",
",",
"lcxid",
"=",
"0x",
"\"",
")",
";",
"pwriter",
"print",
"(",
"long",
"to",
"hex",
"string",
"(",
"last",
"cxid",
")",
")",
";",
"}",
"pwriter",
"print",
"(",
"\"",
",",
"lzxid",
"=",
"0x",
"\"",
")",
";",
"pwriter",
"print",
"(",
"long",
"to",
"hex",
"string",
"(",
"get",
"last",
"zxid",
"(",
")",
")",
")",
";",
"pwriter",
"print",
"(",
"\"",
",",
"lresp",
"=",
"\"",
")",
";",
"pwriter",
"print",
"(",
"get",
"last",
"response",
"time",
"(",
")",
")",
";",
"pwriter",
"print",
"(",
"\"",
",",
"llat",
"=",
"\"",
")",
";",
"pwriter",
"print",
"(",
"get",
"last",
"latency",
"(",
")",
")",
";",
"pwriter",
"print",
"(",
"\"",
",",
"minlat",
"=",
"\"",
")",
";",
"pwriter",
"print",
"(",
"get",
"min",
"latency",
"(",
")",
")",
";",
"pwriter",
"print",
"(",
"\"",
",",
"avglat",
"=",
"\"",
")",
";",
"pwriter",
"print",
"(",
"get",
"avg",
"latency",
"(",
")",
")",
";",
"pwriter",
"print",
"(",
"\"",
",",
"maxlat",
"=",
"\"",
")",
";",
"pwriter",
"print",
"(",
"get",
"max",
"latency",
"(",
")",
")",
";",
"}",
"}",
"pwriter",
"print",
"(",
"\"",
")",
"\"",
")",
";",
"}"
] |
[
"block",
"recovery",
"f",
"i",
"09",
"someall",
"d",
"ns",
"failed",
"to",
"update",
"replicas"
] |
[
"public",
"void",
"test",
"failed",
"replica",
"update",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"log",
"is",
"debug",
"enabled",
"(",
")",
")",
"{",
"log",
"debug",
"(",
"\"",
"running",
"\"",
"+",
"generic",
"test",
"utils",
"get",
"method",
"name",
"(",
")",
")",
";",
"}",
"do",
"throw",
"(",
"new",
"i",
"o",
"exception",
"(",
")",
")",
"when",
"(",
"spy",
"d",
"n",
")",
"update",
"replica",
"under",
"recovery",
"(",
"block",
",",
"recovery",
"id",
",",
"block",
"id",
",",
"block",
"get",
"num",
"bytes",
"(",
")",
")",
";",
"try",
"{",
"block",
"recovery",
"worker",
"recovery",
"task",
"contiguous",
"recovery",
"task",
"contiguous",
"=",
"recovery",
"worker",
"new",
"recovery",
"task",
"contiguous",
"(",
"r",
"block",
")",
";",
"recovery",
"task",
"contiguous",
"sync",
"block",
"(",
"init",
"block",
"records",
"(",
"spy",
"d",
"n",
")",
")",
";",
"fail",
"(",
"\"",
"sync",
"should",
"fail",
"\"",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"e",
"get",
"message",
"(",
")",
"starts",
"with",
"(",
"\"",
"cannot",
"recover",
"\"",
")",
";",
"}",
"}"
] |
[
"register",
"all",
"handlers",
"found",
"in",
"the",
"current",
"application",
"context",
"the",
"actual",
"url",
"determination",
"for",
"a",
"handler",
"is",
"up",
"to",
"the",
"concrete",
"{",
"@",
"link",
"#",
"determine",
"urls",
"for",
"handler",
"(",
"string",
")",
"}",
"implementation",
"a",
"bean",
"for",
"which",
"no",
"such",
"u",
"r",
"ls",
"could",
"be",
"determined",
"is",
"simply",
"not",
"considered",
"a",
"handler"
] |
[
"protected",
"void",
"detect",
"handlers",
"(",
")",
"throws",
"beans",
"exception",
"{",
"application",
"context",
"application",
"context",
"=",
"obtain",
"application",
"context",
"(",
")",
";",
"string",
"[",
"]",
"bean",
"names",
"=",
"(",
"this",
"detect",
"handlers",
"in",
"ancestor",
"contexts",
"?",
"bean",
"factory",
"utils",
"bean",
"names",
"for",
"type",
"including",
"ancestors",
"(",
"application",
"context",
",",
"object",
"class",
")",
":",
"application",
"context",
"get",
"bean",
"names",
"for",
"type",
"(",
"object",
"class",
")",
")",
";",
"/",
"/",
"take",
"any",
"bean",
"name",
"that",
"we",
"can",
"determine",
"u",
"r",
"ls",
"for",
"for",
"(",
"string",
"bean",
"name",
":",
"bean",
"names",
")",
"{",
"string",
"[",
"]",
"urls",
"=",
"determine",
"urls",
"for",
"handler",
"(",
"bean",
"name",
")",
";",
"if",
"(",
"!",
"object",
"utils",
"is",
"empty",
"(",
"urls",
")",
")",
"{",
"/",
"/",
"url",
"paths",
"found",
":",
"let",
"'",
"s",
"consider",
"it",
"a",
"handler",
"register",
"handler",
"(",
"urls",
",",
"bean",
"name",
")",
";",
"}",
"}",
"if",
"(",
"(",
"logger",
"is",
"debug",
"enabled",
"(",
")",
"&",
"&",
"!",
"get",
"handler",
"map",
"(",
")",
"is",
"empty",
"(",
")",
")",
"|",
"|",
"logger",
"is",
"trace",
"enabled",
"(",
")",
")",
"{",
"logger",
"debug",
"(",
"\"",
"detected",
"\"",
"+",
"get",
"handler",
"map",
"(",
")",
"size",
"(",
")",
"+",
"\"",
"mappings",
"in",
"\"",
"+",
"format",
"mapping",
"name",
"(",
")",
")",
";",
"}",
"}"
] |
[
"customize",
"the",
"construction",
"of",
"jackson",
"handlers",
"(",
"{",
"@",
"link",
"json",
"serializer",
"}",
",",
"{",
"@",
"link",
"json",
"deserializer",
"}",
",",
"{",
"@",
"link",
"key",
"deserializer",
"}",
",",
"{",
"@",
"code",
"type",
"resolver",
"builder",
"}",
"and",
"{",
"@",
"code",
"type",
"id",
"resolver",
"}",
")"
] |
[
"public",
"void",
"set",
"handler",
"instantiator",
"(",
"handler",
"instantiator",
"handler",
"instantiator",
")",
"{",
"this",
"builder",
"handler",
"instantiator",
"(",
"handler",
"instantiator",
")",
";",
"}"
] |
[
"obtain",
"the",
"logger",
"with",
"the",
"given",
"name"
] |
[
"private",
"static",
"logger",
"resolve",
"logger",
"(",
"string",
"logger",
"name",
")",
"{",
"if",
"(",
"logger",
"name",
"equals",
"ignore",
"case",
"(",
"\"",
"root",
"\"",
")",
")",
"{",
"return",
"log",
"manager",
"get",
"root",
"logger",
"(",
")",
";",
"}",
"return",
"log",
"manager",
"get",
"logger",
"(",
"logger",
"name",
")",
";",
"}"
] |
[
"method",
"that",
"marks",
"the",
"end",
"of",
"the",
"life",
"-",
"cycle",
"of",
"parallel",
"output",
"instance",
"should",
"be",
"used",
"to",
"close",
"channels",
"and",
"streams",
"and",
"release",
"resources",
"after",
"this",
"method",
"returns",
"without",
"an",
"error",
",",
"the",
"output",
"is",
"assumed",
"to",
"be",
"correct",
"when",
"this",
"method",
"is",
"called",
",",
"the",
"output",
"format",
"it",
"guaranteed",
"to",
"be",
"opened"
] |
[
"void",
"close",
"(",
")",
"throws",
"i",
"o",
"exception",
";"
] |
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
] |
[
"private",
"string",
"to",
"indented",
"string",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"get",
"array",
"number"
] |
[
"public",
"list",
"<",
"big",
"decimal",
">",
"get",
"array",
"number",
"(",
")",
"{",
"return",
"array",
"number",
";",
"}"
] |
[
"get",
"count",
"of",
"tenant",
"based",
"on",
"tenant",
"name"
] |
[
"public",
"long",
"get",
"count",
"(",
"string",
"tenant",
"name",
")",
"{",
"return",
"tenant",
"calls",
"count",
"get",
"(",
"tenant",
"name",
")",
"get",
"(",
")",
";",
"}"
] |
[
"does",
"this",
"introduction",
"advice",
"implement",
"the",
"given",
"interface",
"?"
] |
[
"boolean",
"implements",
"interface",
"(",
"class",
"<",
"?",
">",
"intf",
")",
";"
] |
[
"sets",
"the",
"indices",
"of",
"this",
"index",
"buffer",
"object",
",",
"discarding",
"the",
"old",
"indices",
"the",
"count",
"must",
"equal",
"the",
"number",
"of",
"indices",
"to",
"be",
"copied",
"to",
"this",
"index",
"buffer",
"object",
"this",
"can",
"be",
"called",
"in",
"between",
"calls",
"to",
"{",
"@",
"link",
"#",
"bind",
"(",
")",
"}",
"and",
"{",
"@",
"link",
"#",
"unbind",
"(",
")",
"}",
"the",
"index",
"data",
"will",
"be",
"updated",
"instantly"
] |
[
"public",
"void",
"set",
"indices",
"(",
"short",
"[",
"]",
"indices",
",",
"int",
"offset",
",",
"int",
"count",
")",
"{",
"is",
"dirty",
"=",
"true",
";",
"buffer",
"clear",
"(",
")",
";",
"buffer",
"put",
"(",
"indices",
",",
"offset",
",",
"count",
")",
";",
"buffer",
"flip",
"(",
")",
";",
"if",
"(",
"is",
"bound",
")",
"{",
"gdx",
"gl",
"2",
"0",
"gl",
"buffer",
"data",
"(",
"gl20",
"gl",
"element",
"array",
"buffer",
",",
"buffer",
"limit",
"(",
")",
",",
"buffer",
",",
"usage",
")",
";",
"is",
"dirty",
"=",
"false",
";",
"}",
"}"
] |
[
"checks",
"whether",
"a",
"path",
"exists",
"in",
"the",
"docker",
"container"
] |
[
"public",
"static",
"boolean",
"exists",
"in",
"container",
"(",
"string",
"path",
")",
"{",
"logger",
"debug",
"(",
"\"",
"checking",
"whether",
"file",
"\"",
"+",
"path",
"+",
"\"",
"exists",
"in",
"container",
"\"",
")",
";",
"final",
"shell",
"result",
"result",
"=",
"docker",
"shell",
"run",
"ignore",
"exit",
"code",
"(",
"\"",
"test",
"-",
"e",
"\"",
"+",
"path",
")",
";",
"return",
"result",
"is",
"success",
"(",
")",
";",
"}"
] |
[
"get",
"the",
"name",
"of",
"the",
"current",
"comparison",
"panel",
"being",
"viewed"
] |
[
"public",
"string",
"get",
"current",
"component",
"name",
"(",
")",
"{",
"int",
"selected",
"index",
"=",
"tabbed",
"pane",
"get",
"selected",
"index",
"(",
")",
";",
"if",
"(",
"selected",
"index",
">",
"=",
"0",
")",
"{",
"return",
"tabbed",
"pane",
"get",
"title",
"at",
"(",
"selected",
"index",
")",
";",
"}",
"return",
"null",
";",
"}"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"the",
"same",
"as",
"{",
"@",
"link",
"ghidra",
"screen",
"shot",
"generator",
"#",
"capture",
"isolated",
"provider",
"(",
"class",
",",
"int",
",",
"int",
")",
"}",
"except",
"this",
"method",
"will",
"also",
"capture",
"the",
"containing",
"window"
] |
[
"public",
"void",
"capture",
"isolated",
"provider",
"window",
"(",
"final",
"class",
"<",
"?",
"extends",
"component",
"provider",
">",
"clazz",
",",
"final",
"int",
"width",
",",
"final",
"int",
"height",
")",
"{",
"wait",
"for",
"swing",
"(",
")",
";",
"final",
"component",
"provider",
"provider",
"=",
"tool",
"get",
"window",
"manager",
"(",
")",
"get",
"component",
"provider",
"(",
"clazz",
")",
";",
"if",
"(",
"provider",
"=",
"=",
"null",
")",
"{",
"assert",
"fail",
"(",
"\"",
"could",
"not",
"find",
"provider",
"-",
"-",
"is",
"it",
"installed",
"?",
":",
"\"",
"+",
"clazz",
"get",
"simple",
"name",
"(",
")",
")",
";",
"}",
"move",
"provider",
"to",
"its",
"own",
"window",
"(",
"provider",
")",
";",
"final",
"atomic",
"reference",
"<",
"window",
">",
"ref",
"=",
"new",
"atomic",
"reference",
"<",
">",
"(",
")",
";",
"run",
"swing",
"(",
"(",
")",
"-",
">",
"{",
"window",
"window",
"=",
"tool",
"get",
"window",
"manager",
"(",
")",
"get",
"provider",
"window",
"(",
"provider",
")",
";",
"if",
"(",
"window",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"assert",
"exception",
"(",
"\"",
"could",
"not",
"find",
"window",
"for",
"\"",
"+",
"\"",
"provider",
"-",
"-",
"is",
"it",
"showing",
"?",
":",
"\"",
"+",
"provider",
"get",
"name",
"(",
")",
")",
";",
"}",
"window",
"set",
"size",
"(",
"new",
"dimension",
"(",
"width",
",",
"height",
")",
")",
";",
"ref",
"set",
"(",
"window",
")",
";",
"}",
")",
";",
"wait",
"for",
"swing",
"(",
")",
";",
"capture",
"window",
"(",
"ref",
"get",
"(",
")",
")",
";",
"}"
] |
[
"add",
"a",
"node",
"to",
"the",
"model",
"use",
"any",
"of",
"the",
"part",
"(",
")",
"method",
"to",
"add",
"a",
"node",
"part"
] |
[
"public",
"node",
"node",
"(",
")",
"{",
"final",
"node",
"node",
"=",
"new",
"node",
"(",
")",
";",
"node",
"(",
"node",
")",
";",
"node",
"id",
"=",
"\"",
"node",
"\"",
"+",
"model",
"nodes",
"size",
";",
"return",
"node",
";",
"}"
] |
[
"remove",
"the",
"task",
"identified",
"by",
"the",
"given",
"execution",
"attempt",
"id"
] |
[
"public",
"t",
"remove",
"(",
"execution",
"attempt",
"i",
"d",
"execution",
"attempt",
"id",
")",
"{",
"return",
"tasks",
"remove",
"(",
"execution",
"attempt",
"id",
")",
";",
"}"
] |
[
"returns",
"the",
"type",
"matcher",
"which",
"chooses",
"which",
"types",
"the",
"listener",
"should",
"be",
"notified",
"of"
] |
[
"public",
"matcher",
"<",
"?",
"super",
"type",
"literal",
"<",
"?",
">",
">",
"get",
"type",
"matcher",
"(",
")",
"{",
"return",
"type",
"matcher",
";",
"}"
] |
[
"tests",
"that",
"teh",
"{",
"@",
"link",
"mapper",
"service",
"}",
"created",
"by",
"{",
"@",
"link",
"indices",
"service",
"#",
"create",
"index",
"mapper",
"service",
"(",
"index",
"metadata",
")",
"}",
"contains",
"custom",
"types",
"and",
"similarities",
"registered",
"by",
"plugins"
] |
[
"public",
"void",
"test",
"stand",
"alone",
"mapper",
"service",
"with",
"plugins",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"final",
"string",
"index",
"name",
"=",
"\"",
"test",
"\"",
";",
"final",
"index",
"index",
"=",
"new",
"index",
"(",
"index",
"name",
",",
"u",
"u",
"i",
"ds",
"random",
"base",
"6",
"4",
"u",
"u",
"i",
"d",
"(",
")",
")",
";",
"final",
"indices",
"service",
"indices",
"service",
"=",
"get",
"indices",
"service",
"(",
")",
";",
"final",
"settings",
"idx",
"settings",
"=",
"settings",
"builder",
"(",
")",
"put",
"(",
"index",
"metadata",
"setting",
"version",
"created",
",",
"version",
"current",
")",
"put",
"(",
"index",
"metadata",
"setting",
"index",
"uuid",
",",
"index",
"get",
"u",
"u",
"i",
"d",
"(",
")",
")",
"put",
"(",
"index",
"module",
"similarity",
"settings",
"prefix",
"+",
"\"",
"test",
"type",
"\"",
",",
"\"",
"fake",
"-",
"similarity",
"\"",
")",
"build",
"(",
")",
";",
"final",
"index",
"metadata",
"index",
"metadata",
"=",
"new",
"index",
"metadata",
"builder",
"(",
"index",
"get",
"name",
"(",
")",
")",
"settings",
"(",
"idx",
"settings",
")",
"number",
"of",
"shards",
"(",
"1",
")",
"number",
"of",
"replicas",
"(",
"0",
")",
"build",
"(",
")",
";",
"mapper",
"service",
"mapper",
"service",
"=",
"indices",
"service",
"create",
"index",
"mapper",
"service",
"(",
"index",
"metadata",
")",
";",
"assert",
"not",
"null",
"(",
"mapper",
"service",
"parser",
"context",
"(",
")",
"type",
"parser",
"(",
"\"",
"fake",
"-",
"mapper",
"\"",
")",
")",
";",
"similarity",
"sim",
"=",
"mapper",
"service",
"parser",
"context",
"(",
")",
"get",
"similarity",
"(",
"\"",
"test",
"\"",
")",
"get",
"(",
")",
";",
"assert",
"that",
"(",
"sim",
",",
"instance",
"of",
"(",
"non",
"negative",
"scores",
"similarity",
"class",
")",
")",
";",
"sim",
"=",
"(",
"(",
"non",
"negative",
"scores",
"similarity",
")",
"sim",
")",
"get",
"delegate",
"(",
")",
";",
"assert",
"that",
"(",
"sim",
",",
"instance",
"of",
"(",
"b",
"m",
"2",
"5",
"similarity",
"class",
")",
")",
";",
"}"
] |
[
"a",
"sensor",
"shape",
"collects",
"contact",
"information",
"but",
"never",
"generates",
"a",
"collision",
"response"
] |
[
"public",
"boolean",
"is",
"sensor",
"(",
")",
"{",
"return",
"is",
"sensor",
";",
"}"
] |
[
"sets",
"the",
"resources",
"for",
"this",
"operator",
"this",
"overrides",
"the",
"default",
"minimum",
"and",
"preferred",
"resources"
] |
[
"private",
"o",
"set",
"resources",
"(",
"resource",
"spec",
"resources",
")",
"{",
"operator",
"validation",
"utils",
"validate",
"resources",
"(",
"resources",
")",
";",
"this",
"min",
"resources",
"=",
"resources",
";",
"this",
"preferred",
"resources",
"=",
"resources",
";",
"@",
"suppress",
"warnings",
"(",
"\"",
"unchecked",
"\"",
")",
"o",
"return",
"type",
"=",
"(",
"o",
")",
"this",
";",
"return",
"return",
"type",
";",
"}"
] |
[
"returns",
"the",
"type",
"of",
"the",
"match"
] |
[
"public",
"pattern",
"match",
"type",
"get",
"match",
"type",
"(",
")",
"{",
"return",
"match",
"type",
";",
"}"
] |
[
"find",
"the",
"fields",
"constant",
"that",
"matches",
"field",
"id",
",",
"or",
"null",
"if",
"its",
"not",
"found"
] |
[
"public",
"static",
"fields",
"find",
"by",
"thrift",
"id",
"(",
"int",
"field",
"id",
")",
"{",
"switch",
"(",
"field",
"id",
")",
"{",
"case",
"1",
":",
"/",
"/",
"int",
"arg",
"return",
"int",
"arg",
";",
"case",
"2",
":",
"/",
"/",
"long",
"arg",
"return",
"long",
"arg",
";",
"case",
"3",
":",
"/",
"/",
"string",
"arg",
"return",
"string",
"arg",
";",
"case",
"4",
":",
"/",
"/",
"bool",
"arg",
"return",
"bool",
"arg",
";",
"case",
"5",
":",
"/",
"/",
"binary",
"arg",
"return",
"binary",
"arg",
";",
"case",
"6",
":",
"/",
"/",
"double",
"arg",
"return",
"double",
"arg",
";",
"default",
":",
"return",
"null",
";",
"}",
"}"
] |
[
"convenience",
"method",
"to",
"execute",
"an",
"update",
"with",
"no",
"parameters"
] |
[
"public",
"int",
"update",
"(",
")",
"throws",
"data",
"access",
"exception",
"{",
"return",
"update",
"(",
"new",
"object",
"[",
"0",
"]",
")",
";",
"}"
] |
[
"config",
"properties",
"for",
"this",
"component"
] |
[
"public",
"component",
"configuration",
"(",
"configuration",
"configuration",
")",
"{",
"this",
"configuration",
"=",
"configuration",
";",
"return",
"this",
";",
"}"
] |
[
"creates",
"a",
"function",
"by",
"examining",
"the",
"instructions",
"to",
"find",
"the",
"body"
] |
[
"public",
"function",
"create",
"function",
"(",
"string",
"address",
"string",
")",
"{",
"return",
"tx",
"(",
"(",
")",
"-",
">",
"{",
"address",
"address",
"=",
"addr",
"(",
"address",
"string",
")",
";",
"create",
"function",
"cmd",
"cmd",
"=",
"new",
"create",
"function",
"cmd",
"(",
"address",
")",
";",
"cmd",
"apply",
"to",
"(",
"program",
")",
";",
"return",
"cmd",
"get",
"function",
"(",
")",
";",
"}",
")",
";",
"}"
] |
[
"write",
"the",
"given",
"long",
"value",
"as",
"a",
"4",
"byte",
"unsigned",
"integer",
"overflow",
"is",
"ignored"
] |
[
"public",
"static",
"void",
"write",
"unsigned",
"int",
"(",
"byte",
"buffer",
"buffer",
",",
"int",
"index",
",",
"long",
"value",
")",
"{",
"buffer",
"put",
"int",
"(",
"index",
",",
"(",
"int",
")",
"(",
"value",
"&",
"0xffffffff",
"l",
")",
")",
";",
"}"
] |
[
"called",
"by",
"the",
"filter",
"after",
"it",
"decides",
"that",
"the",
"request",
"is",
"a",
"potential",
"csrf",
"attack",
"and",
"therefore",
"must",
"be",
"rejected"
] |
[
"void",
"send",
"error",
"(",
"int",
"code",
",",
"string",
"message",
")",
"throws",
"i",
"o",
"exception",
";"
] |
[
"show",
"the",
"listing",
"merge",
"panel",
"with",
"each",
"listing",
"positioned",
"to",
"the",
"indicated",
"address",
"a",
"null",
"can",
"be",
"passed",
"for",
"any",
"address",
"to",
"indicate",
"that",
"listing",
"should",
"be",
"empty"
] |
[
"public",
"void",
"show",
"listing",
"merge",
"panel",
"(",
"final",
"address",
"result",
"address",
",",
"final",
"address",
"latest",
"address",
",",
"final",
"address",
"my",
"address",
",",
"final",
"address",
"original",
"address",
")",
"{",
"swing",
"utilities",
"invoke",
"later",
"(",
"new",
"runnable",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"run",
"(",
")",
"{",
"show",
"merge",
"tool",
"(",
")",
";",
"if",
"(",
"!",
"is",
"showing",
"listing",
"merge",
"panel",
")",
"{",
"merge",
"panel",
"add",
"domain",
"object",
"listener",
"(",
")",
";",
"listing",
"plugin",
"=",
"new",
"listing",
"merge",
"panel",
"plugin",
"(",
"merge",
"tool",
",",
"merge",
"panel",
")",
";",
"go",
"to",
"plugin",
"=",
"new",
"go",
"to",
"address",
"label",
"plugin",
"(",
"merge",
"tool",
")",
";",
"try",
"{",
"merge",
"tool",
"add",
"plugin",
"(",
"listing",
"plugin",
")",
";",
"merge",
"tool",
"add",
"plugin",
"(",
"go",
"to",
"plugin",
")",
";",
"}",
"catch",
"(",
"plugin",
"exception",
"e",
")",
"{",
"e",
"print",
"stack",
"trace",
"(",
")",
";",
"}",
"merge",
"plugin",
"set",
"merge",
"component",
"(",
"merge",
"panel",
",",
"\"",
"listing",
"merge",
"\"",
")",
";",
"/",
"/",
"unlock",
"the",
"individual",
"listing",
"panels",
"so",
"they",
"can",
"move",
"/",
"display",
"independent",
"addresses",
"/",
"/",
"todo",
"/",
"/",
"dimension",
"d",
"=",
"merge",
"panel",
"get",
"preferred",
"size",
"(",
")",
";",
"/",
"/",
"merge",
"tool",
"set",
"size",
"(",
"d",
"width",
"+",
"20",
",",
"d",
"height",
"+",
"20",
")",
";",
"/",
"/",
"point",
"center",
"loc",
"=",
"window",
"utilities",
"center",
"on",
"screen",
"(",
"merge",
"tool",
"get",
"size",
"(",
")",
")",
";",
"/",
"/",
"merge",
"tool",
"set",
"location",
"(",
"center",
"loc",
"x",
",",
"center",
"loc",
"y",
")",
";",
"}",
"load",
"externals",
"into",
"merge",
"panel",
"(",
"result",
"address",
",",
"latest",
"address",
",",
"my",
"address",
",",
"original",
"address",
")",
";",
"is",
"showing",
"listing",
"merge",
"panel",
"=",
"true",
";",
"}",
"private",
"void",
"load",
"externals",
"into",
"merge",
"panel",
"(",
"final",
"address",
"result",
"address",
",",
"final",
"address",
"latest",
"address",
",",
"final",
"address",
"my",
"address",
",",
"final",
"address",
"original",
"address",
")",
"{",
"program",
"specific",
"address",
"translator",
"translator",
"=",
"new",
"program",
"specific",
"address",
"translator",
"(",
")",
";",
"translator",
"add",
"program",
"address",
"(",
"get",
"program",
"(",
"merge",
"constants",
"result",
")",
",",
"result",
"address",
")",
";",
"translator",
"add",
"program",
"address",
"(",
"get",
"program",
"(",
"merge",
"constants",
"latest",
")",
",",
"latest",
"address",
")",
";",
"translator",
"add",
"program",
"address",
"(",
"get",
"program",
"(",
"merge",
"constants",
"my",
")",
",",
"my",
"address",
")",
";",
"translator",
"add",
"program",
"address",
"(",
"get",
"program",
"(",
"merge",
"constants",
"original",
")",
",",
"original",
"address",
")",
";",
"merge",
"panel",
"set",
"address",
"translator",
"(",
"translator",
")",
";",
"merge",
"panel",
"go",
"to",
"(",
"result",
"address",
",",
"merge",
"constants",
"result",
")",
";",
"merge",
"panel",
"go",
"to",
"(",
"latest",
"address",
",",
"merge",
"constants",
"latest",
")",
";",
"merge",
"panel",
"go",
"to",
"(",
"my",
"address",
",",
"merge",
"constants",
"my",
")",
";",
"merge",
"panel",
"go",
"to",
"(",
"original",
"address",
",",
"merge",
"constants",
"original",
")",
";",
"merge",
"panel",
"validate",
"(",
")",
";",
"}",
"}",
")",
";",
"input",
"received",
"=",
"false",
";",
"/",
"/",
"block",
"until",
"the",
"user",
"takes",
"action",
"wait",
"for",
"input",
"(",
")",
";",
"}"
] |
[
"validate",
"any",
"cross",
"-",
"field",
"references",
"made",
"by",
"this",
"mapper"
] |
[
"public",
"abstract",
"void",
"validate",
"(",
"mapping",
"lookup",
"mappers",
")",
";"
] |
[
"finds",
"the",
"first",
"record",
"of",
"a",
"single",
"table",
"person",
"p",
"=",
"lite",
"pal",
"find",
"first",
"(",
"person",
"class",
")",
";",
"note",
"that",
"the",
"associated",
"models",
"won",
"'",
"t",
"be",
"loaded",
"by",
"default",
"considering",
"the",
"efficiency",
",",
"but",
"you",
"can",
"do",
"that",
"by",
"using",
"{",
"@",
"link",
"lite",
"pal",
"#",
"find",
"first",
"(",
"class",
",",
"boolean",
")",
"}"
] |
[
"public",
"static",
"<",
"t",
">",
"t",
"find",
"first",
"(",
"class",
"<",
"t",
">",
"model",
"class",
")",
"{",
"return",
"operator",
"find",
"first",
"(",
"model",
"class",
")",
";",
"}"
] |
[
"deletes",
"the",
"{",
"@",
"link",
"fingerprint",
"}",
"in",
"the",
"configured",
"storage",
"with",
"the",
"given",
"unique",
"id"
] |
[
"public",
"static",
"void",
"delete",
"(",
"@",
"non",
"null",
"string",
"id",
")",
"throws",
"i",
"o",
"exception",
"{",
"fingerprint",
"storage",
"configured",
"fingerprint",
"storage",
"=",
"fingerprint",
"storage",
"get",
"(",
")",
";",
"fingerprint",
"storage",
"file",
"fingerprint",
"storage",
"=",
"fingerprint",
"storage",
"get",
"file",
"fingerprint",
"storage",
"(",
")",
";",
"configured",
"fingerprint",
"storage",
"delete",
"(",
"id",
")",
";",
"if",
"(",
"!",
"(",
"configured",
"fingerprint",
"storage",
"instanceof",
"file",
"fingerprint",
"storage",
")",
"&",
"&",
"file",
"fingerprint",
"storage",
"is",
"ready",
"(",
")",
")",
"{",
"file",
"fingerprint",
"storage",
"delete",
"(",
"id",
")",
";",
"}",
"}"
] |
[
"get",
"a",
"file",
"name",
"with",
"the",
"full",
"path",
"included",
"based",
"on",
"a",
"file",
"index"
] |
[
"public",
"string",
"get",
"full",
"file",
"by",
"index",
"(",
"int",
"index",
")",
"{",
"if",
"(",
"index",
"<",
"0",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"negative",
"file",
"index",
"was",
"given",
"\"",
")",
";",
"}",
"if",
"(",
"this",
"line",
"=",
"=",
"null",
")",
"{",
"return",
"null",
";",
"}",
"return",
"this",
"line",
"get",
"full",
"file",
"(",
"index",
",",
"this",
"comp",
"dir",
")",
";",
"}"
] |
[
"set",
"boolean",
"group"
] |
[
"public",
"a",
"p",
"itest",
"group",
"parameters",
"request",
"boolean",
"group",
"(",
"boolean",
"boolean",
"group",
")",
"{",
"this",
"boolean",
"group",
"=",
"boolean",
"group",
";",
"return",
"this",
";",
"}"
] |
[
"returns",
"an",
"{",
"@",
"link",
"observable",
"}",
"that",
"automatically",
"connects",
"(",
"at",
"most",
"once",
")",
"to",
"this",
"{",
"@",
"code",
"connectable",
"observable",
"}",
"when",
"the",
"specified",
"number",
"of",
"{",
"@",
"link",
"observer",
"}",
"s",
"subscribe",
"to",
"it",
"and",
"calls",
"the",
"specified",
"callback",
"with",
"the",
"{",
"@",
"link",
"disposable",
"}",
"associated",
"with",
"the",
"established",
"connection",
"<",
"img",
"width",
"=",
"\"",
"640",
"\"",
"height",
"=",
"\"",
"348",
"\"",
"src",
"=",
"\"",
"https",
":",
"raw",
"github",
"comwiki",
"reactive",
"x",
"rx",
"javaimagesrx",
"-",
"operatorsauto",
"connect",
"o",
"png",
"\"",
"alt",
"=",
"\"",
"\"",
">",
"the",
"connection",
"happens",
"after",
"the",
"given",
"number",
"of",
"subscriptions",
"and",
"happens",
"at",
"most",
"once",
"during",
"the",
"lifetime",
"of",
"the",
"returned",
"{",
"@",
"code",
"observable",
"}",
"if",
"this",
"{",
"@",
"code",
"connectable",
"observable",
"}",
"terminates",
",",
"the",
"connection",
"is",
"never",
"renewed",
",",
"no",
"matter",
"how",
"{",
"@",
"code",
"observer",
"}",
"s",
"come",
"and",
"go",
"use",
"{",
"@",
"link",
"#",
"ref",
"count",
"(",
")",
"}",
"to",
"renew",
"a",
"connection",
"or",
"dispose",
"an",
"active",
"connection",
"when",
"all",
"{",
"@",
"code",
"observer",
"}",
"s",
"have",
"disposed",
"their",
"{",
"@",
"code",
"disposable",
"}",
"s",
"<",
"dl",
">",
"<",
"dt",
">",
"<",
"b",
">",
"scheduler",
":",
"<",
"b",
">",
"<",
"dt",
">",
"<",
"dd",
">",
"{",
"@",
"code",
"auto",
"connect",
"}",
"overload",
"does",
"not",
"operate",
"on",
"any",
"particular",
"{",
"@",
"link",
"scheduler",
"}",
"<",
"dd",
">",
"<",
"dl",
">"
] |
[
"public",
"observable",
"<",
"t",
">",
"auto",
"connect",
"(",
"int",
"number",
"of",
"observers",
",",
"@",
"non",
"null",
"consumer",
"<",
"?",
"super",
"disposable",
">",
"connection",
")",
"{",
"objects",
"require",
"non",
"null",
"(",
"connection",
",",
"\"",
"connection",
"is",
"null",
"\"",
")",
";",
"if",
"(",
"number",
"of",
"observers",
"<",
"=",
"0",
")",
"{",
"this",
"connect",
"(",
"connection",
")",
";",
"return",
"rx",
"java",
"plugins",
"on",
"assembly",
"(",
"this",
")",
";",
"}",
"return",
"rx",
"java",
"plugins",
"on",
"assembly",
"(",
"new",
"observable",
"auto",
"connect",
"<",
">",
"(",
"this",
",",
"number",
"of",
"observers",
",",
"connection",
")",
")",
";",
"}"
] |
[
"get",
"userlogin",
":",
"logs",
"user",
"into",
"the",
"system"
] |
[
"default",
"response",
"entity",
"<",
"string",
">",
"login",
"user",
"(",
"@",
"not",
"null",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"the",
"user",
"name",
"for",
"login",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"param",
"(",
"value",
"=",
"\"",
"username",
"\"",
",",
"required",
"=",
"true",
")",
"string",
"username",
",",
"@",
"not",
"null",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"the",
"password",
"for",
"login",
"in",
"clear",
"text",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"valid",
"@",
"request",
"param",
"(",
"value",
"=",
"\"",
"password",
"\"",
",",
"required",
"=",
"true",
")",
"string",
"password",
")",
"{",
"return",
"get",
"delegate",
"(",
")",
"login",
"user",
"(",
"username",
",",
"password",
")",
";",
"}"
] |
[
"guaranteed",
"to",
"throw",
"an",
"exception",
"and",
"leave",
"the",
"collection",
"unmodified"
] |
[
"public",
"final",
"boolean",
"set",
"count",
"(",
"e",
"element",
",",
"int",
"old",
"count",
",",
"int",
"new",
"count",
")",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
")",
";",
"}"
] |
[
"required",
"for",
"backcompatibility",
"with",
"num",
"key",
"fields",
"for",
"partition",
"in",
"{",
"@",
"link",
"key",
"field",
"based",
"partitioner",
"}"
] |
[
"public",
"void",
"set",
"key",
"field",
"spec",
"(",
"int",
"start",
",",
"int",
"end",
")",
"{",
"if",
"(",
"end",
">",
"=",
"start",
")",
"{",
"key",
"description",
"k",
"=",
"new",
"key",
"description",
"(",
")",
";",
"k",
"begin",
"field",
"idx",
"=",
"start",
";",
"k",
"end",
"field",
"idx",
"=",
"end",
";",
"key",
"spec",
"seen",
"=",
"true",
";",
"all",
"key",
"specs",
"add",
"(",
"k",
")",
";",
"}",
"}"
] |
[
"get",
"namespace",
"array"
] |
[
"public",
"list",
"<",
"integer",
">",
"get",
"namespace",
"array",
"(",
")",
"{",
"return",
"namespace",
"array",
";",
"}"
] |
[
"whether",
"this",
"reference",
"is",
"referencing",
"a",
"private",
"resource",
"(",
"&",
"#",
"64",
";",
"package",
":",
"typeentry",
")",
"<",
"code",
">",
"optional",
"bool",
"private",
"=",
"4",
";",
"<",
"code",
">"
] |
[
"public",
"boolean",
"get",
"private",
"(",
")",
"{",
"return",
"private",
";",
"}"
] |
[
"returns",
"the",
"bit",
"at",
"the",
"given",
"index",
"and",
"sets",
"it",
"in",
"one",
"go"
] |
[
"public",
"boolean",
"get",
"and",
"set",
"(",
"int",
"index",
")",
"{",
"final",
"int",
"word",
"=",
"index",
">",
">",
">",
"6",
";",
"check",
"capacity",
"(",
"word",
")",
";",
"long",
"old",
"bits",
"=",
"bits",
"[",
"word",
"]",
";",
"bits",
"[",
"word",
"]",
"|",
"=",
"1l",
"<",
"<",
"(",
"index",
"&",
"0x",
"3",
"f",
")",
";",
"return",
"bits",
"[",
"word",
"]",
"=",
"=",
"old",
"bits",
";",
"}"
] |
[
"returns",
"the",
"configured",
"target",
"for",
"the",
"specified",
"label",
",",
"configured",
"for",
"the",
"\"",
"host",
"\"",
"configuration"
] |
[
"protected",
"configured",
"target",
"get",
"host",
"configured",
"target",
"(",
"string",
"label",
")",
"throws",
"label",
"syntax",
"exception",
"{",
"return",
"get",
"configured",
"target",
"(",
"label",
",",
"get",
"host",
"configuration",
"(",
")",
")",
";",
"}"
] |
[
"gets",
"a",
"value",
"indicating",
"whether",
"the",
"match",
"operation",
"succeeded"
] |
[
"public",
"boolean",
"succeeded",
"(",
")",
"{",
"return",
"mismatched",
"node",
"=",
"=",
"null",
";",
"}"
] |
[
"copies",
"the",
"specified",
"remote",
"file",
"to",
"local",
"nm",
"aux",
"service",
"directory",
"if",
"the",
"same",
"file",
"already",
"exists",
"(",
"as",
"determined",
"by",
"modification",
"time",
")",
",",
"the",
"file",
"will",
"not",
"be",
"copied",
"again"
] |
[
"protected",
"path",
"maybe",
"download",
"jars",
"(",
"string",
"s",
"name",
",",
"string",
"class",
"name",
",",
"string",
"remote",
"file",
",",
"aux",
"service",
"file",
"type",
"enum",
"type",
",",
"configuration",
"conf",
")",
"throws",
"i",
"o",
"exception",
"{",
"/",
"/",
"load",
"auxiliary",
"service",
"from",
"remote",
"classpath",
"file",
"context",
"local",
"l",
"f",
"s",
"=",
"get",
"local",
"file",
"context",
"(",
"conf",
")",
";",
"/",
"/",
"create",
"nm",
"aux",
"-",
"service",
"dir",
"in",
"nm",
"localdir",
"if",
"it",
"does",
"not",
"exist",
"path",
"nm",
"aux",
"dir",
"=",
"dirs",
"handler",
"get",
"local",
"path",
"for",
"write",
"(",
"\"",
"\"",
"+",
"path",
"separator",
"+",
"nm",
"aux",
"service",
"dir",
")",
";",
"if",
"(",
"!",
"local",
"l",
"f",
"s",
"util",
"(",
")",
"exists",
"(",
"nm",
"aux",
"dir",
")",
")",
"{",
"try",
"{",
"local",
"l",
"f",
"s",
"mkdir",
"(",
"nm",
"aux",
"dir",
",",
"nm",
"aux",
"service",
"dir",
"perm",
",",
"true",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"ex",
")",
"{",
"throw",
"new",
"yarn",
"runtime",
"exception",
"(",
"\"",
"fail",
"to",
"create",
"dir",
":",
"\"",
"+",
"nm",
"aux",
"dir",
"to",
"string",
"(",
")",
",",
"ex",
")",
";",
"}",
"}",
"path",
"src",
"=",
"new",
"path",
"(",
"remote",
"file",
")",
";",
"file",
"context",
"remote",
"l",
"f",
"s",
"=",
"get",
"remote",
"file",
"context",
"(",
"src",
"to",
"uri",
"(",
")",
",",
"conf",
")",
";",
"file",
"status",
"sc",
"file",
"status",
"=",
"remote",
"l",
"f",
"s",
"get",
"file",
"status",
"(",
"src",
")",
";",
"if",
"(",
"!",
"sc",
"file",
"status",
"get",
"owner",
"(",
")",
"equals",
"(",
"this",
"user",
"u",
"g",
"i",
"get",
"short",
"user",
"name",
"(",
")",
")",
")",
"{",
"throw",
"new",
"yarn",
"runtime",
"exception",
"(",
"\"",
"the",
"remote",
"jarfile",
"owner",
":",
"\"",
"+",
"sc",
"file",
"status",
"get",
"owner",
"(",
")",
"+",
"\"",
"is",
"not",
"the",
"same",
"as",
"the",
"nm",
"user",
":",
"\"",
"+",
"this",
"user",
"u",
"g",
"i",
"get",
"short",
"user",
"name",
"(",
")",
"+",
"\"",
"\"",
")",
";",
"}",
"if",
"(",
"(",
"sc",
"file",
"status",
"get",
"permission",
"(",
")",
"to",
"short",
"(",
")",
"&",
"0022",
")",
"!",
"=",
"0",
")",
"{",
"throw",
"new",
"yarn",
"runtime",
"exception",
"(",
"\"",
"the",
"remote",
"jarfile",
"should",
"not",
"\"",
"+",
"\"",
"be",
"writable",
"by",
"group",
"or",
"others",
"\"",
"+",
"\"",
"the",
"current",
"permission",
"is",
"\"",
"+",
"sc",
"file",
"status",
"get",
"permission",
"(",
")",
"to",
"short",
"(",
")",
")",
";",
"}",
"path",
"download",
"dest",
"=",
"new",
"path",
"(",
"nm",
"aux",
"dir",
",",
"class",
"name",
"+",
"\"",
"\"",
"+",
"sc",
"file",
"status",
"get",
"modification",
"time",
"(",
")",
")",
";",
"/",
"/",
"check",
"whether",
"we",
"need",
"to",
"re",
"-",
"download",
"the",
"jar",
"/",
"/",
"from",
"remote",
"directory",
"path",
"target",
"dir",
"path",
"=",
"new",
"path",
"(",
"download",
"dest",
",",
"sc",
"file",
"status",
"get",
"path",
"(",
")",
"get",
"name",
"(",
")",
")",
";",
"file",
"status",
"[",
"]",
"all",
"sub",
"dirs",
"=",
"local",
"l",
"f",
"s",
"util",
"(",
")",
"list",
"status",
"(",
"nm",
"aux",
"dir",
")",
";",
"for",
"(",
"file",
"status",
"sub",
":",
"all",
"sub",
"dirs",
")",
"{",
"if",
"(",
"sub",
"get",
"path",
"(",
")",
"get",
"name",
"(",
")",
"equals",
"(",
"download",
"dest",
"get",
"name",
"(",
")",
")",
")",
"{",
"return",
"target",
"dir",
"path",
";",
"}",
"else",
"{",
"if",
"(",
"sub",
"get",
"path",
"(",
")",
"get",
"name",
"(",
")",
"contains",
"(",
"class",
"name",
")",
"&",
"&",
"!",
"sub",
"get",
"path",
"(",
")",
"get",
"name",
"(",
")",
"ends",
"with",
"(",
"del",
"suffix",
")",
")",
"{",
"path",
"del",
"path",
"=",
"new",
"path",
"(",
"sub",
"get",
"path",
"(",
")",
"get",
"parent",
"(",
")",
",",
"sub",
"get",
"path",
"(",
")",
"get",
"name",
"(",
")",
"+",
"del",
"suffix",
")",
";",
"local",
"l",
"f",
"s",
"rename",
"(",
"sub",
"get",
"path",
"(",
")",
",",
"del",
"path",
")",
";",
"log",
"info",
"(",
"\"",
"delete",
"old",
"aux",
"service",
"jar",
"dir",
":",
"\"",
"+",
"del",
"path",
"to",
"string",
"(",
")",
")",
";",
"file",
"deletion",
"task",
"deletion",
"task",
"=",
"new",
"file",
"deletion",
"task",
"(",
"this",
"del",
"service",
",",
"null",
",",
"del",
"path",
",",
"null",
")",
";",
"this",
"del",
"service",
"delete",
"(",
"deletion",
"task",
")",
";",
"}",
"}",
"}",
"local",
"resource",
"type",
"src",
"type",
";",
"if",
"(",
"type",
"=",
"=",
"aux",
"service",
"file",
"type",
"enum",
"static",
")",
"{",
"src",
"type",
"=",
"local",
"resource",
"type",
"file",
";",
"}",
"else",
"if",
"(",
"type",
"=",
"=",
"aux",
"service",
"file",
"type",
"enum",
"archive",
")",
"{",
"src",
"type",
"=",
"local",
"resource",
"type",
"archive",
";",
"}",
"else",
"{",
"throw",
"new",
"yarn",
"runtime",
"exception",
"(",
"\"",
"cannot",
"unpack",
"file",
"of",
"type",
"\"",
"+",
"type",
"+",
"\"",
"from",
"remote",
"-",
"file",
"-",
"path",
":",
"\"",
"+",
"src",
"+",
"\"",
"for",
"aux",
"-",
"service",
":",
"\"",
"+",
"\"",
"\\",
"n",
"\"",
")",
";",
"}",
"local",
"resource",
"sc",
"rsrc",
"=",
"local",
"resource",
"new",
"instance",
"(",
"url",
"from",
"u",
"r",
"i",
"(",
"src",
"to",
"uri",
"(",
")",
")",
",",
"src",
"type",
",",
"local",
"resource",
"visibility",
"private",
",",
"sc",
"file",
"status",
"get",
"len",
"(",
")",
",",
"sc",
"file",
"status",
"get",
"modification",
"time",
"(",
")",
")",
";",
"f",
"s",
"download",
"download",
"=",
"new",
"f",
"s",
"download",
"(",
"local",
"l",
"f",
"s",
",",
"null",
",",
"conf",
",",
"download",
"dest",
",",
"sc",
"rsrc",
",",
"null",
")",
";",
"try",
"{",
"/",
"/",
"don",
"'",
"t",
"need",
"to",
"convert",
"downloaded",
"path",
"into",
"a",
"dir",
"/",
"/",
"since",
"it",
"'",
"s",
"already",
"a",
"jar",
"path",
"return",
"download",
"call",
"(",
")",
";",
"}",
"catch",
"(",
"exception",
"ex",
")",
"{",
"throw",
"new",
"yarn",
"runtime",
"exception",
"(",
"\"",
"exception",
"happend",
"while",
"downloading",
"files",
"\"",
"+",
"\"",
"for",
"aux",
"-",
"service",
":",
"\"",
"+",
"s",
"name",
"+",
"\"",
"and",
"remote",
"-",
"file",
"-",
"path",
":",
"\"",
"+",
"src",
"+",
"\"",
"\\",
"n",
"\"",
"+",
"ex",
"get",
"message",
"(",
")",
")",
";",
"}",
"}"
] |
[
"try",
"to",
"locate",
"the",
"required",
"token",
"for",
"the",
"server"
] |
[
"private",
"token",
"<",
"?",
">",
"get",
"server",
"token",
"(",
"sasl",
"auth",
"auth",
"type",
")",
"throws",
"i",
"o",
"exception",
"{",
"token",
"info",
"token",
"info",
"=",
"security",
"util",
"get",
"token",
"info",
"(",
"protocol",
",",
"conf",
")",
";",
"log",
"debug",
"(",
"\"",
"get",
"token",
"info",
"proto",
":",
"\"",
"+",
"protocol",
"+",
"\"",
"info",
":",
"\"",
"+",
"token",
"info",
")",
";",
"if",
"(",
"token",
"info",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"protocol",
"has",
"no",
"support",
"for",
"tokens",
"return",
"null",
";",
"}",
"token",
"selector",
"<",
"?",
">",
"token",
"selector",
"=",
"null",
";",
"try",
"{",
"token",
"selector",
"=",
"token",
"info",
"value",
"(",
")",
"new",
"instance",
"(",
")",
";",
"}",
"catch",
"(",
"instantiation",
"exception",
"|",
"illegal",
"access",
"exception",
"e",
")",
"{",
"throw",
"new",
"i",
"o",
"exception",
"(",
"e",
"to",
"string",
"(",
")",
",",
"e",
")",
";",
"}",
"return",
"token",
"selector",
"select",
"token",
"(",
"security",
"util",
"build",
"token",
"service",
"(",
"server",
"addr",
")",
",",
"ugi",
"get",
"tokens",
"(",
")",
")",
";",
"}"
] |
[
"example",
"1",
"implementation",
"of",
"the",
"switch",
"view"
] |
[
"private",
"bi",
"ad",
"adapter",
"switcher",
"imple",
"switch",
"view",
"(",
"final",
"ultimate",
"recycler",
"view",
"rv",
")",
"{",
"final",
"adap",
"adp",
"1",
"=",
"new",
"adap",
"(",
"createadmob",
"(",
")",
",",
"new",
"array",
"list",
"<",
"string",
">",
"(",
")",
")",
";",
"final",
"regular",
"adp",
"2",
"=",
"new",
"regular",
"(",
"new",
"array",
"list",
"<",
"string",
">",
"(",
")",
")",
";",
"final",
"bi",
"ad",
"adapter",
"switcher",
"switchable",
"=",
"new",
"bi",
"ad",
"adapter",
"switcher",
"(",
"rv",
",",
"adp",
"2",
",",
"adp",
"1",
")",
";",
"return",
"switchable",
";",
"}"
] |
[
"test",
"the",
"audit",
"log",
"format",
"with",
"key",
"-",
"val",
"pair"
] |
[
"public",
"void",
"test",
"key",
"val",
"log",
"format",
"(",
")",
"throws",
"exception",
"{",
"string",
"builder",
"act",
"log",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"string",
"builder",
"exp",
"log",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"/",
"/",
"add",
"the",
"first",
"k",
"=",
"v",
"pair",
"and",
"check",
"r",
"m",
"audit",
"logger",
"start",
"(",
"keys",
"user",
",",
"user",
",",
"act",
"log",
")",
";",
"exp",
"log",
"append",
"(",
"\"",
"user",
"=",
"test",
"\"",
")",
";",
"assert",
"equals",
"(",
"exp",
"log",
"to",
"string",
"(",
")",
",",
"act",
"log",
"to",
"string",
"(",
")",
")",
";",
"/",
"/",
"append",
"another",
"k",
"1",
"=",
"v",
"1",
"pair",
"to",
"already",
"added",
"k",
"=",
"v",
"and",
"test",
"r",
"m",
"audit",
"logger",
"add",
"(",
"keys",
"operation",
",",
"operation",
",",
"act",
"log",
")",
";",
"exp",
"log",
"append",
"(",
"\"",
"\\",
"t",
"o",
"p",
"e",
"r",
"a",
"t",
"i",
"o",
"n",
"=",
"oper",
"\"",
")",
";",
"assert",
"equals",
"(",
"exp",
"log",
"to",
"string",
"(",
")",
",",
"act",
"log",
"to",
"string",
"(",
")",
")",
";",
"/",
"/",
"append",
"another",
"k",
"1",
"=",
"null",
"pair",
"and",
"test",
"r",
"m",
"audit",
"logger",
"add",
"(",
"keys",
"appid",
",",
"(",
"string",
")",
"null",
",",
"act",
"log",
")",
";",
"exp",
"log",
"append",
"(",
"\"",
"\\",
"t",
"a",
"p",
"p",
"i",
"d",
"=",
"null",
"\"",
")",
";",
"assert",
"equals",
"(",
"exp",
"log",
"to",
"string",
"(",
")",
",",
"act",
"log",
"to",
"string",
"(",
")",
")",
";",
"/",
"/",
"now",
"add",
"the",
"target",
"and",
"check",
"of",
"the",
"final",
"string",
"r",
"m",
"audit",
"logger",
"add",
"(",
"keys",
"target",
",",
"target",
",",
"act",
"log",
")",
";",
"exp",
"log",
"append",
"(",
"\"",
"\\",
"t",
"t",
"a",
"r",
"g",
"e",
"t",
"=",
"tgt",
"\"",
")",
";",
"assert",
"equals",
"(",
"exp",
"log",
"to",
"string",
"(",
")",
",",
"act",
"log",
"to",
"string",
"(",
")",
")",
";",
"}"
] |
[
"returns",
"the",
"appropriate",
"instance",
"for",
"the",
"given",
"injection",
"key",
";",
"equivalent",
"to",
"{",
"@",
"code",
"get",
"provider",
"(",
"key",
")",
"get",
"(",
")",
"}",
"when",
"feasible",
",",
"avoid",
"using",
"this",
"method",
",",
"in",
"favor",
"of",
"having",
"guice",
"inject",
"your",
"dependencies",
"ahead",
"of",
"time"
] |
[
"<",
"t",
">",
"t",
"get",
"instance",
"(",
"key",
"<",
"t",
">",
"key",
")",
";"
] |
[
"find",
"purchase",
"order",
"by",
"id",
"for",
"valid",
"response",
"try",
"integer",
"i",
"ds",
"with",
"value",
"&",
"lt",
";",
"&",
"#",
"x",
"3",
"d",
";",
"5",
"or",
"&",
"gt",
";",
"10",
"other",
"values",
"will",
"generated",
"exceptions"
] |
[
"public",
"single",
"<",
"order",
">",
"rx",
"get",
"order",
"by",
"id",
"(",
"long",
"order",
"id",
",",
"api",
"client",
"auth",
"info",
"auth",
"info",
")",
"{",
"return",
"single",
"create",
"(",
"new",
"io",
"vertx",
"rx",
"java",
"single",
"on",
"subscribe",
"adapter",
"<",
">",
"(",
"fut",
"-",
">",
"delegate",
"get",
"order",
"by",
"id",
"(",
"order",
"id",
",",
"auth",
"info",
",",
"fut",
")",
")",
")",
";",
"}"
] |
[
"parses",
"an",
"{",
"@",
"code",
"exceptions",
"}",
"attribute"
] |
[
"private",
"attribute",
"exceptions",
"(",
"direct",
"class",
"file",
"cf",
",",
"int",
"offset",
",",
"int",
"length",
",",
"parse",
"observer",
"observer",
")",
"{",
"if",
"(",
"length",
"<",
"2",
")",
"{",
"return",
"throw",
"severely",
"truncated",
"(",
")",
";",
"}",
"byte",
"array",
"bytes",
"=",
"cf",
"get",
"bytes",
"(",
")",
";",
"int",
"count",
"=",
"bytes",
"get",
"unsigned",
"short",
"(",
"offset",
")",
";",
"/",
"/",
"number",
"of",
"exceptions",
"if",
"(",
"observer",
"!",
"=",
"null",
")",
"{",
"observer",
"parsed",
"(",
"bytes",
",",
"offset",
",",
"2",
",",
"\"",
"number",
"of",
"exceptions",
":",
"\"",
"+",
"hex",
"u",
"2",
"(",
"count",
")",
")",
";",
"}",
"offset",
"+",
"=",
"2",
";",
"length",
"-",
"=",
"2",
";",
"if",
"(",
"length",
"!",
"=",
"(",
"count",
"*",
"2",
")",
")",
"{",
"throw",
"bad",
"length",
"(",
"(",
"count",
"*",
"2",
")",
"+",
"2",
")",
";",
"}",
"type",
"list",
"list",
"=",
"cf",
"make",
"type",
"list",
"(",
"offset",
",",
"count",
")",
";",
"return",
"new",
"att",
"exceptions",
"(",
"list",
")",
";",
"}"
] |
[
"<",
"code",
">",
"merge",
"bookmarks",
"<",
"code",
">",
"merges",
"bookmark",
"differences",
"from",
"the",
"origin",
"program",
"to",
"the",
"result",
"program",
"within",
"the",
"specified",
"address",
"set"
] |
[
"void",
"merge",
"bookmarks",
"(",
"address",
"set",
"view",
"origin",
"address",
"set",
",",
"task",
"monitor",
"monitor",
")",
"throws",
"cancelled",
"exception",
",",
"unsupported",
"operation",
"exception",
"{",
"if",
"(",
"!",
"origin",
"to",
"result",
"translator",
"is",
"one",
"for",
"one",
"translator",
"(",
")",
")",
"{",
"string",
"message",
"=",
"origin",
"to",
"result",
"translator",
"get",
"class",
"(",
")",
"get",
"name",
"(",
")",
"+",
"\"",
"is",
"not",
"a",
"one",
"for",
"one",
"translator",
"and",
"can",
"'",
"t",
"merge",
"bookmarks",
"\"",
";",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
"message",
")",
";",
"}",
"monitor",
"set",
"message",
"(",
"\"",
"applying",
"bookmarks",
"\"",
")",
";",
"if",
"(",
"origin",
"address",
"set",
"is",
"empty",
"(",
")",
")",
"{",
"return",
";",
"}",
"/",
"/",
"get",
"the",
"addresses",
"in",
"the",
"set",
"address",
"iterator",
"origin",
"iter",
"=",
"origin",
"address",
"set",
"get",
"addresses",
"(",
"true",
")",
";",
"/",
"/",
"get",
"each",
"address",
"in",
"the",
"address",
"set",
"and",
"change",
"the",
"bookmark",
"for",
"(",
"long",
"count",
"=",
"0",
";",
"origin",
"iter",
"has",
"next",
"(",
")",
"&",
"&",
"!",
"monitor",
"is",
"cancelled",
"(",
")",
";",
"count",
"+",
"+",
")",
"{",
"monitor",
"check",
"canceled",
"(",
")",
";",
"address",
"origin",
"address",
"=",
"origin",
"iter",
"next",
"(",
")",
";",
"if",
"(",
"count",
"=",
"=",
"progress",
"counter",
"granularity",
")",
"{",
"monitor",
"set",
"message",
"(",
"\"",
"applying",
"bookmarks",
"\"",
"+",
"origin",
"address",
"to",
"string",
"(",
"true",
")",
")",
";",
"count",
"=",
"0",
";",
"}",
"merge",
"bookmarks",
"at",
"address",
"(",
"origin",
"address",
")",
";",
"}",
"}"
] |
[
"get",
"the",
"client",
"used",
"for",
"test",
"administrative",
"actions",
"do",
"not",
"use",
"this",
"while",
"writing",
"a",
"test",
"only",
"use",
"it",
"for",
"cleaning",
"up",
"after",
"tests"
] |
[
"protected",
"static",
"rest",
"client",
"admin",
"client",
"(",
")",
"{",
"return",
"admin",
"client",
";",
"}"
] |
[
"utility",
"function",
"to",
"add",
"a",
"new",
"decoded",
"data"
] |
[
"protected",
"void",
"add",
"http",
"data",
"(",
"interface",
"http",
"data",
"data",
")",
"{",
"if",
"(",
"data",
"=",
"=",
"null",
")",
"{",
"return",
";",
"}",
"list",
"<",
"interface",
"http",
"data",
">",
"datas",
"=",
"body",
"map",
"http",
"data",
"get",
"(",
"data",
"get",
"name",
"(",
")",
")",
";",
"if",
"(",
"datas",
"=",
"=",
"null",
")",
"{",
"datas",
"=",
"new",
"array",
"list",
"<",
"interface",
"http",
"data",
">",
"(",
"1",
")",
";",
"body",
"map",
"http",
"data",
"put",
"(",
"data",
"get",
"name",
"(",
")",
",",
"datas",
")",
";",
"}",
"datas",
"add",
"(",
"data",
")",
";",
"body",
"list",
"http",
"data",
"add",
"(",
"data",
")",
";",
"}"
] |
[
"add",
"a",
"new",
"pet",
"to",
"the",
"store"
] |
[
"void",
"add",
"pet",
"(",
"pet",
"body",
")",
";"
] |
[
"adds",
"a",
"group",
"of",
"objects",
"that",
"are",
"supposed",
"to",
"be",
"equivalent",
"to",
"each",
"other",
"and",
"not",
"equivalent",
"to",
"objects",
"in",
"any",
"other",
"equivalence",
"group",
"added",
"to",
"this",
"tester"
] |
[
"public",
"equivalence",
"tester",
"<",
"t",
">",
"add",
"equivalence",
"group",
"(",
"t",
"first",
",",
"t",
"rest",
")",
"{",
"add",
"equivalence",
"group",
"(",
"lists",
"as",
"list",
"(",
"first",
",",
"rest",
")",
")",
";",
"return",
"this",
";",
"}"
] |
[
"tests",
"new",
"support",
"added",
"as",
"a",
"result",
"of",
"<",
"a",
"href",
"=",
"\"",
"https",
":",
"opensource",
"atlassian",
"comprojectsspringbrowse",
"s",
"p",
"r",
"-",
"2660",
"\"",
"target",
"=",
"\"",
"blank",
"\"",
">",
"spr",
"-",
"2660",
"specifically",
",",
"if",
"the",
"{",
"@",
"code",
"items",
"}",
"attribute",
"is",
"supplied",
"a",
"{",
"@",
"link",
"map",
"}",
",",
"and",
"{",
"@",
"code",
"item",
"value",
"}",
"and",
"{",
"@",
"code",
"item",
"label",
"}",
"are",
"supplied",
"non",
"-",
"null",
"values",
",",
"then",
":",
"{",
"@",
"code",
"item",
"value",
"}",
"will",
"be",
"used",
"as",
"the",
"property",
"name",
"of",
"the",
"map",
"'",
"s",
"key",
",",
"and",
"{",
"@",
"code",
"item",
"label",
"}",
"will",
"be",
"used",
"as",
"the",
"property",
"name",
"of",
"the",
"map",
"'",
"s",
"value"
] |
[
"public",
"void",
"with",
"multi",
"map",
"with",
"item",
"value",
"and",
"item",
"label",
"(",
")",
"throws",
"exception",
"{",
"/",
"/",
"save",
"original",
"default",
"locale",
"final",
"locale",
"default",
"locale",
"=",
"locale",
"get",
"default",
"(",
")",
";",
"/",
"/",
"use",
"a",
"locale",
"that",
"doesn",
"'",
"t",
"result",
"in",
"the",
"generation",
"of",
"html",
"entities",
"/",
"/",
"(",
"e",
"g",
",",
"not",
"german",
",",
"where",
"\\",
"u",
"0",
"0e",
"4",
"becomes",
"&",
"auml",
";",
")",
"locale",
"set",
"default",
"(",
"locale",
"us",
")",
";",
"try",
"{",
"final",
"country",
"austria",
"=",
"country",
"country",
"at",
";",
"final",
"country",
"usa",
"=",
"country",
"country",
"us",
";",
"final",
"map",
"some",
"map",
"=",
"new",
"hash",
"map",
"(",
")",
";",
"some",
"map",
"put",
"(",
"austria",
",",
"locale",
"at",
")",
";",
"some",
"map",
"put",
"(",
"usa",
",",
"locale",
"us",
")",
";",
"this",
"bean",
"set",
"some",
"map",
"(",
"some",
"map",
")",
";",
"this",
"tag",
"set",
"path",
"(",
"\"",
"some",
"map",
"\"",
")",
";",
"/",
"/",
"see",
":",
"test",
"bean",
"this",
"tag",
"set",
"items",
"(",
"get",
"country",
"to",
"locale",
"map",
"(",
")",
")",
";",
"this",
"tag",
"set",
"item",
"value",
"(",
"\"",
"iso",
"code",
"\"",
")",
";",
"/",
"/",
"map",
"key",
":",
"country",
"this",
"tag",
"set",
"item",
"label",
"(",
"\"",
"display",
"language",
"\"",
")",
";",
"/",
"/",
"map",
"value",
":",
"locale",
"bean",
"property",
"binding",
"result",
"binding",
"result",
"=",
"new",
"bean",
"property",
"binding",
"result",
"(",
"get",
"test",
"bean",
"(",
")",
",",
"command",
"name",
")",
";",
"binding",
"result",
"get",
"property",
"accessor",
"(",
")",
"register",
"custom",
"editor",
"(",
"country",
"class",
",",
"new",
"property",
"editor",
"support",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"set",
"as",
"text",
"(",
"final",
"string",
"text",
")",
"throws",
"illegal",
"argument",
"exception",
"{",
"set",
"value",
"(",
"country",
"get",
"country",
"with",
"iso",
"code",
"(",
"text",
")",
")",
";",
"}",
"@",
"override",
"public",
"string",
"get",
"as",
"text",
"(",
")",
"{",
"return",
"(",
"(",
"country",
")",
"get",
"value",
"(",
")",
")",
"get",
"iso",
"code",
"(",
")",
";",
"}",
"}",
")",
";",
"expose",
"binding",
"result",
"(",
"binding",
"result",
")",
";",
"int",
"result",
"=",
"this",
"tag",
"do",
"start",
"tag",
"(",
")",
";",
"assert",
"that",
"(",
"result",
")",
"is",
"equal",
"to",
"(",
"tag",
"skip",
"body",
")",
";",
"string",
"output",
"=",
"get",
"output",
"(",
")",
";",
"output",
"=",
"\"",
"<",
"doc",
">",
"\"",
"+",
"output",
"+",
"\"",
"<",
"/",
"doc",
">",
"\"",
";",
"s",
"a",
"x",
"reader",
"reader",
"=",
"new",
"s",
"a",
"x",
"reader",
"(",
")",
";",
"document",
"document",
"=",
"reader",
"read",
"(",
"new",
"string",
"reader",
"(",
"output",
")",
")",
";",
"element",
"root",
"element",
"=",
"document",
"get",
"root",
"element",
"(",
")",
";",
"assert",
"that",
"(",
"root",
"element",
"elements",
"(",
")",
"size",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"2",
")",
";",
"element",
"select",
"element",
"=",
"root",
"element",
"element",
"(",
"\"",
"select",
"\"",
")",
";",
"assert",
"that",
"(",
"select",
"element",
"get",
"name",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"\"",
"select",
"\"",
")",
";",
"assert",
"that",
"(",
"select",
"element",
"attribute",
"(",
"\"",
"name",
"\"",
")",
"get",
"value",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"\"",
"some",
"map",
"\"",
")",
";",
"list",
"children",
"=",
"select",
"element",
"elements",
"(",
")",
";",
"assert",
"that",
"(",
"children",
"size",
"(",
")",
")",
"as",
"(",
"\"",
"incorrect",
"number",
"of",
"children",
"\"",
")",
"is",
"equal",
"to",
"(",
"3",
")",
";",
"element",
"e",
";",
"e",
"=",
"(",
"element",
")",
"select",
"element",
"select",
"single",
"node",
"(",
"\"",
"option",
"[",
"@",
"value",
"=",
"'",
"\"",
"+",
"austria",
"get",
"iso",
"code",
"(",
")",
"+",
"\"",
"'",
"]",
"\"",
")",
";",
"assert",
"that",
"(",
"e",
")",
"as",
"(",
"\"",
"option",
"node",
"not",
"found",
"with",
"country",
"iso",
"code",
"value",
"[",
"\"",
"+",
"austria",
"get",
"iso",
"code",
"(",
")",
"+",
"\"",
"]",
"\"",
")",
"is",
"not",
"null",
"(",
")",
";",
"assert",
"that",
"(",
"e",
"attribute",
"(",
"\"",
"selected",
"\"",
")",
"get",
"value",
"(",
")",
")",
"as",
"(",
"\"",
"at",
"node",
"not",
"selected",
"\"",
")",
"is",
"equal",
"to",
"(",
"\"",
"selected",
"\"",
")",
";",
"assert",
"that",
"(",
"e",
"get",
"data",
"(",
")",
")",
"as",
"(",
"\"",
"at",
"locale",
"display",
"language",
"property",
"not",
"used",
"for",
"option",
"label",
"\"",
")",
"is",
"equal",
"to",
"(",
"locale",
"at",
"get",
"display",
"language",
"(",
")",
")",
";",
"e",
"=",
"(",
"element",
")",
"select",
"element",
"select",
"single",
"node",
"(",
"\"",
"option",
"[",
"@",
"value",
"=",
"'",
"\"",
"+",
"usa",
"get",
"iso",
"code",
"(",
")",
"+",
"\"",
"'",
"]",
"\"",
")",
";",
"assert",
"that",
"(",
"e",
")",
"as",
"(",
"\"",
"option",
"node",
"not",
"found",
"with",
"country",
"iso",
"code",
"value",
"[",
"\"",
"+",
"usa",
"get",
"iso",
"code",
"(",
")",
"+",
"\"",
"]",
"\"",
")",
"is",
"not",
"null",
"(",
")",
";",
"assert",
"that",
"(",
"e",
"attribute",
"(",
"\"",
"selected",
"\"",
")",
"get",
"value",
"(",
")",
")",
"as",
"(",
"\"",
"us",
"node",
"not",
"selected",
"\"",
")",
"is",
"equal",
"to",
"(",
"\"",
"selected",
"\"",
")",
";",
"assert",
"that",
"(",
"e",
"get",
"data",
"(",
")",
")",
"as",
"(",
"\"",
"us",
"locale",
"display",
"language",
"property",
"not",
"used",
"for",
"option",
"label",
"\"",
")",
"is",
"equal",
"to",
"(",
"locale",
"us",
"get",
"display",
"language",
"(",
")",
")",
";",
"}",
"finally",
"{",
"/",
"/",
"restore",
"original",
"default",
"locale",
"locale",
"set",
"default",
"(",
"default",
"locale",
")",
";",
"}",
"}"
] |
[
"creates",
"a",
"dynamic",
"string",
"field",
"based",
"on",
"a",
"matching",
"dynamic",
"template",
"no",
"field",
"is",
"created",
"in",
"case",
"there",
"is",
"no",
"matching",
"dynamic",
"template"
] |
[
"void",
"create",
"dynamic",
"string",
"field",
"from",
"template",
"(",
"parse",
"context",
"context",
",",
"string",
"name",
")",
"throws",
"i",
"o",
"exception",
"{",
"create",
"dynamic",
"field",
"(",
"context",
",",
"name",
",",
"dynamic",
"template",
"x",
"content",
"field",
"type",
"string",
",",
"(",
")",
"-",
">",
"{",
"}",
")",
";",
"}"
] |
[
"name",
"the",
"thread",
"to",
"the",
"current",
"test",
"method"
] |
[
"public",
"void",
"name",
"thread",
"(",
")",
"{",
"thread",
"current",
"thread",
"(",
")",
"set",
"name",
"(",
"\"",
"j",
"unit",
"-",
"\"",
"+",
"method",
"name",
"get",
"method",
"name",
"(",
")",
")",
";",
"}"
] |
[
"add",
"a",
"{",
"@",
"link",
"tag",
"}",
"to",
"the",
"step"
] |
[
"startup",
"step",
"tag",
"(",
"string",
"key",
",",
"supplier",
"<",
"string",
">",
"value",
")",
";"
] |
[
"get",
"the",
"number",
"of",
"contacts",
"(",
"each",
"may",
"have",
"0",
"or",
"more",
"contact",
"points",
")"
] |
[
"public",
"int",
"get",
"contact",
"count",
"(",
")",
"{",
"return",
"jni",
"get",
"contact",
"count",
"(",
"addr",
")",
";",
"}"
] |
[
"checks",
"whether",
"unaligned",
"checkpoints",
"are",
"forced",
",",
"despite",
"currently",
"non",
"-",
"checkpointable",
"iteration",
"feedback"
] |
[
"public",
"void",
"set",
"force",
"unaligned",
"checkpoints",
"(",
"boolean",
"force",
"unaligned",
"checkpoints",
")",
"{",
"this",
"force",
"unaligned",
"checkpoints",
"=",
"force",
"unaligned",
"checkpoints",
";",
"}"
] |
[
"set",
"the",
"additional",
"(",
"undeclared",
")",
"property",
"with",
"the",
"specified",
"name",
"and",
"value",
"if",
"the",
"property",
"does",
"not",
"already",
"exist",
",",
"create",
"it",
"otherwise",
"replace",
"it"
] |
[
"public",
"additional",
"properties",
"array",
"put",
"additional",
"property",
"(",
"string",
"key",
",",
"list",
"value",
")",
"{",
"if",
"(",
"this",
"additional",
"properties",
"=",
"=",
"null",
")",
"{",
"this",
"additional",
"properties",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"list",
">",
"(",
")",
";",
"}",
"this",
"additional",
"properties",
"put",
"(",
"key",
",",
"value",
")",
";",
"return",
"this",
";",
"}"
] |
[
"add",
"a",
"new",
"exception",
"to",
"the",
"store",
"if",
"the",
"same",
"exception",
"already",
"exists",
",",
"it",
"increases",
"the",
"occurrences",
"if",
"we",
"already",
"get",
"the",
"maximum",
"number",
"of",
"exceptions",
",",
"it",
"doesn",
"'",
"t",
"add",
"any",
"value"
] |
[
"public",
"long",
"put",
"(",
"string",
"name",
",",
"@",
"non",
"null",
"throwable",
"t",
")",
"{",
"/",
"/",
"a",
"final",
"object",
"to",
"pass",
"it",
"to",
"the",
"function",
"final",
"atomic",
"long",
"occurrences",
"=",
"new",
"atomic",
"long",
"(",
")",
";",
"/",
"/",
"we",
"need",
"the",
"key",
"(",
"the",
"stack",
"trace",
")",
"to",
"be",
"a",
"list",
"and",
"unmodifiable",
"list",
"<",
"stack",
"trace",
"element",
">",
"key",
"=",
"collections",
"unmodifiable",
"list",
"(",
"arrays",
"as",
"list",
"(",
"t",
"get",
"stack",
"trace",
"(",
")",
")",
")",
";",
"final",
"missing",
"class",
"event",
"new",
"event",
"=",
"new",
"missing",
"class",
"event",
"(",
"name",
",",
"t",
")",
";",
"events",
"compute",
"(",
"key",
",",
"(",
"stack",
"trace",
"elements",
",",
"missing",
"class",
"event",
")",
"-",
">",
"{",
"if",
"(",
"missing",
"class",
"event",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"it",
"'",
"s",
"a",
"new",
"element",
",",
"the",
"size",
"will",
"increase",
"if",
"(",
"events",
"size",
"(",
")",
"<",
"max",
"events",
"per",
"send",
")",
"{",
"/",
"/",
"create",
"the",
"new",
"value",
"occurrences",
"set",
"(",
"1",
")",
";",
"return",
"new",
"event",
";",
"}",
"else",
"{",
"return",
"null",
";",
"}",
"}",
"else",
"{",
"/",
"/",
"we",
"update",
"the",
"occurrences",
"and",
"the",
"last",
"time",
"it",
"happened",
"occurrences",
"set",
"(",
"missing",
"class",
"event",
"get",
"occurrences",
"(",
")",
")",
";",
"missing",
"class",
"event",
"set",
"occurrences",
"(",
"occurrences",
"increment",
"and",
"get",
"(",
")",
")",
";",
"missing",
"class",
"event",
"set",
"time",
"(",
"missing",
"class",
"telemetry",
"client",
"date",
"string",
"(",
")",
")",
";",
"return",
"missing",
"class",
"event",
";",
"}",
"}",
")",
";",
"/",
"/",
"we",
"add",
"the",
"event",
"to",
"the",
"list",
"of",
"already",
"printed",
"events",
"we",
"used",
"the",
"name",
"of",
"the",
"missing",
"class",
"instead",
"of",
"the",
"/",
"/",
"full",
"stack",
"trace",
"as",
"a",
"key",
"to",
"avoid",
"filling",
"the",
"log",
"with",
"cnfe",
"talking",
"about",
"the",
"same",
"class",
"even",
"though",
"the",
"/",
"/",
"stack",
"traces",
"are",
"different",
"worse",
"scenario",
",",
"if",
"we",
"don",
"'",
"t",
"put",
"the",
"exception",
"on",
"the",
"ignored",
"places",
"correctly",
",",
"/",
"/",
"the",
"administrator",
"will",
"see",
"the",
"message",
"again",
"and",
"we",
"will",
"be",
"able",
"to",
"add",
"the",
"new",
"one",
"to",
"the",
"ignored",
"places",
"/",
"/",
"in",
"addition",
",",
"the",
"event",
"is",
"also",
"sent",
"to",
"telemetry",
"events",
"on",
"this",
"execution",
"put",
"if",
"absent",
"(",
"name",
",",
"new",
"event",
")",
";",
"return",
"occurrences",
"get",
"(",
")",
";",
"}"
] |
[
"get",
"anytype",
"2"
] |
[
"public",
"object",
"get",
"anytype",
"2",
"(",
")",
"{",
"return",
"anytype",
"2",
";",
"}"
] |
[
"returns",
"the",
"header",
"length"
] |
[
"public",
"long",
"get",
"header",
"length",
"(",
")",
"{",
"return",
"header",
"length",
";",
"}"
] |
[
"sets",
"the",
"dynamic",
"with",
"the",
"specified",
"(",
"enum",
")",
"type",
"to",
"the",
"specified",
"value"
] |
[
"public",
"void",
"set",
"dynamic",
"value",
"(",
"elf",
"dynamic",
"type",
"type",
",",
"long",
"value",
")",
"{",
"set",
"dynamic",
"value",
"(",
"type",
"value",
",",
"value",
")",
";",
"}"
] |
[
"get",
"the",
"list",
"of",
"options",
"for",
"all",
"categories"
] |
[
"public",
"tool",
"options",
"[",
"]",
"get",
"options",
"(",
")",
"{",
"tool",
"options",
"[",
"]",
"opt",
"=",
"new",
"tool",
"options",
"[",
"options",
"map",
"size",
"(",
")",
"]",
";",
"int",
"idx",
"=",
"0",
";",
"iterator",
"<",
"string",
">",
"iter",
"=",
"options",
"map",
"key",
"set",
"(",
")",
"iterator",
"(",
")",
";",
"while",
"(",
"iter",
"has",
"next",
"(",
")",
")",
"{",
"string",
"key",
"=",
"iter",
"next",
"(",
")",
";",
"opt",
"[",
"idx",
"]",
"=",
"options",
"map",
"get",
"(",
"key",
")",
";",
"+",
"+",
"idx",
";",
"}",
"arrays",
"sort",
"(",
"opt",
",",
"new",
"options",
"comparator",
"(",
")",
")",
";",
"return",
"opt",
";",
"}"
] |
[
"the",
"name",
"of",
"the",
"enumflag",
"as",
"a",
"reference",
"enumsflag",
"items",
"are",
"generated",
"as",
"id",
"resource",
"values",
"<",
"code",
">",
"optional",
"aapt",
"pb",
"reference",
"name",
"=",
"3",
";",
"<",
"code",
">"
] |
[
"public",
"boolean",
"has",
"name",
"(",
")",
"{",
"return",
"instance",
"has",
"name",
"(",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"map",
"'"
] |
[
"public",
"void",
"map",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"map",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.