docstring_tokens
list | code_tokens
list |
|---|---|
[
"combine",
"all",
"sets",
"in",
"the",
"array",
"returned",
"the",
"or",
"'",
"d",
"value"
] | [
"public",
"static",
"interval",
"set",
"or",
"(",
"interval",
"set",
"[",
"]",
"sets",
")",
"{",
"interval",
"set",
"r",
"=",
"new",
"interval",
"set",
"(",
")",
";",
"for",
"(",
"interval",
"set",
"s",
":",
"sets",
")",
"r",
"add",
"all",
"(",
"s",
")",
";",
"return",
"r",
";",
"}"
] |
[
"creates",
"and",
"sets",
"hystrix",
"command",
"properties"
] | [
"public",
"static",
"hystrix",
"command",
"properties",
"setter",
"initialize",
"command",
"properties",
"(",
"list",
"<",
"hystrix",
"property",
">",
"properties",
")",
"throws",
"illegal",
"argument",
"exception",
"{",
"return",
"initialize",
"properties",
"(",
"hystrix",
"command",
"properties",
"setter",
"(",
")",
",",
"properties",
",",
"cmd",
"prop",
"map",
",",
"\"",
"command",
"\"",
")",
";",
"}"
] |
[
"returns",
"the",
"maximum",
"automaton",
"states",
"allowed",
"for",
"fuzzy",
"expansion"
] | [
"public",
"int",
"get",
"max",
"determinized",
"states",
"(",
")",
"{",
"return",
"max",
"determinized",
"states",
";",
"}"
] |
[
"set",
"the",
"agent",
"id",
"of",
"the",
"{",
"@",
"code",
"m",
"bean",
"server",
"}",
"to",
"locate",
"default",
"is",
"none",
"if",
"specified",
",",
"this",
"will",
"result",
"in",
"an",
"automatic",
"attempt",
"being",
"made",
"to",
"locate",
"the",
"attendant",
"m",
"bean",
"server",
",",
"and",
"(",
"importantly",
")",
"if",
"said",
"m",
"bean",
"server",
"cannot",
"be",
"located",
"no",
"attempt",
"will",
"be",
"made",
"to",
"create",
"a",
"new",
"m",
"bean",
"server",
"(",
"and",
"an",
"m",
"bean",
"server",
"not",
"found",
"exception",
"will",
"be",
"thrown",
"at",
"resolution",
"time",
")",
"specifying",
"the",
"empty",
"string",
"indicates",
"the",
"platform",
"m",
"bean",
"server"
] | [
"public",
"void",
"set",
"agent",
"id",
"(",
"string",
"agent",
"id",
")",
"{",
"this",
"agent",
"id",
"=",
"agent",
"id",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"kind",
"'"
] | [
"public",
"void",
"kind",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"kind",
"}"
] |
[
"retrieve",
"the",
"location",
"in",
"the",
"code",
"viewer",
"'",
"s",
"{",
"@",
"link",
"field",
"panel",
"}",
"for",
"the",
"field",
"at",
"the",
"given",
"address",
"having",
"the",
"given",
"header",
"text"
] | [
"protected",
"field",
"location",
"find",
"field",
"location",
"(",
"address",
"addr",
",",
"string",
"field",
"name",
")",
"{",
"layout",
"layout",
"=",
"listpane",
"get",
"layout",
"(",
"addr",
")",
";",
"listing",
"model",
"adapter",
"adapter",
"=",
"(",
"listing",
"model",
"adapter",
")",
"codepane",
"get",
"layout",
"model",
"(",
")",
";",
"big",
"integer",
"index",
"=",
"adapter",
"get",
"address",
"index",
"map",
"(",
")",
"get",
"index",
"(",
"addr",
")",
";",
"int",
"count",
"=",
"layout",
"get",
"num",
"fields",
"(",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"count",
";",
"i",
"+",
"+",
")",
"{",
"listing",
"field",
"field",
"=",
"(",
"listing",
"field",
")",
"layout",
"get",
"field",
"(",
"i",
")",
";",
"if",
"(",
"field",
"get",
"field",
"factory",
"(",
")",
"get",
"field",
"name",
"(",
")",
"equals",
"(",
"field",
"name",
")",
")",
"{",
"return",
"new",
"field",
"location",
"(",
"index",
",",
"i",
")",
";",
"}",
"}",
"return",
"null",
";",
"}"
] |
[
"get",
"a",
"display",
"string",
"for",
"the",
"given",
"value",
",",
"converted",
"by",
"a",
"property",
"editor",
"that",
"the",
"bind",
"status",
"may",
"have",
"registered",
"for",
"the",
"value",
"'",
"s",
"class"
] | [
"protected",
"string",
"convert",
"to",
"display",
"string",
"(",
"@",
"nullable",
"object",
"value",
")",
"throws",
"jsp",
"exception",
"{",
"property",
"editor",
"editor",
"=",
"(",
"value",
"!",
"=",
"null",
"?",
"get",
"bind",
"status",
"(",
")",
"find",
"editor",
"(",
"value",
"get",
"class",
"(",
")",
")",
":",
"null",
")",
";",
"return",
"get",
"display",
"string",
"(",
"value",
",",
"editor",
")",
";",
"}"
] |
[
"execute",
"{",
"@",
"code",
"s",
"3",
"a",
"file",
"system",
"#",
"inner",
"get",
"file",
"status",
"(",
"path",
",",
"boolean",
",",
"set",
")",
"}",
"for",
"the",
"given",
"probes",
"expect",
"the",
"specific",
"headlist",
"count",
"with",
"a",
"raw",
"fs"
] | [
"public",
"s",
"3",
"a",
"file",
"status",
"verify",
"raw",
"inner",
"get",
"file",
"status",
"(",
"path",
"path",
",",
"boolean",
"need",
"empty",
"directory",
"flag",
",",
"set",
"<",
"status",
"probe",
"enum",
">",
"probes",
",",
"operation",
"cost",
"cost",
")",
"throws",
"exception",
"{",
"return",
"verify",
"raw",
"(",
"cost",
",",
"(",
")",
"-",
">",
"inner",
"get",
"file",
"status",
"(",
"get",
"file",
"system",
"(",
")",
",",
"path",
",",
"need",
"empty",
"directory",
"flag",
",",
"probes",
")",
")",
";",
"}"
] |
[
"sets",
"the",
"test",
"byte",
"buf",
"allocator",
"this",
"allocator",
"will",
"be",
"used",
"by",
"all",
"future",
"instances",
"of",
"this",
"class",
"it",
"is",
"not",
"recommended",
"to",
"use",
"this",
"method",
"outside",
"of",
"testing"
] | [
"static",
"void",
"set",
"test",
"allocator",
"(",
"byte",
"buf",
"allocator",
"allocator",
")",
"{",
"test",
"allocator",
"set",
"(",
"allocator",
")",
";",
"}"
] |
[
"when",
"an",
"attribute",
"includes",
"multiple",
"selects",
",",
"we",
"don",
"'",
"t",
"allow",
"duplicates",
"even",
"across",
"selects",
"(",
"this",
"saves",
"us",
"from",
"having",
"to",
"do",
"possibly",
"expensive",
"value",
"iteration",
"since",
"the",
"number",
"of",
"values",
"can",
"grow",
"exponentially",
"with",
"respect",
"to",
"the",
"number",
"of",
"selects",
")"
] | [
"public",
"void",
"duplicates",
"across",
"multiple",
"selects",
"(",
")",
"throws",
"exception",
"{",
"write",
"config",
"rules",
"(",
")",
";",
"scratch",
"file",
"(",
"\"",
"java",
"/",
"hello",
"/",
"build",
"\"",
",",
"\"",
"java",
"binary",
"(",
"\"",
",",
"\"",
"name",
"=",
"'",
"hello",
"'",
",",
"\"",
",",
"\"",
"srcs",
"=",
"select",
"(",
"{",
"\"",
",",
"\"",
"'",
"/",
"/",
"conditions",
":",
"a",
"'",
":",
"[",
"'",
"a",
"java",
"'",
"]",
",",
"\"",
",",
"\"",
"'",
"/",
"/",
"conditions",
":",
"b",
"'",
":",
"[",
"'",
"b",
"java",
"'",
"]",
",",
"\"",
",",
"\"",
"}",
")",
"\"",
",",
"\"",
"+",
"select",
"(",
"{",
"\"",
",",
"\"",
"'",
"/",
"/",
"conditions",
":",
"c",
"'",
":",
"[",
"'",
"c",
"java",
"'",
"]",
",",
"\"",
",",
"\"",
"'",
"/",
"/",
"conditions",
":",
"d",
"'",
":",
"[",
"'",
"a",
"java",
"'",
"]",
",",
"\"",
",",
"\"",
"}",
")",
")",
"\"",
")",
";",
"reporter",
"remove",
"handler",
"(",
"fail",
"fast",
"handler",
")",
";",
"/",
"/",
"expect",
"errors",
"use",
"configuration",
"(",
"\"",
"-",
"-",
"test",
"arg",
"=",
"a",
"\"",
")",
";",
"get",
"configured",
"target",
"(",
"\"",
"/",
"/",
"java",
"/",
"hello",
":",
"hello",
"\"",
")",
";",
"assert",
"contains",
"event",
"(",
"\"",
"label",
"'",
"/",
"/",
"java",
"/",
"hello",
":",
"a",
"java",
"'",
"is",
"duplicated",
"in",
"the",
"'",
"srcs",
"'",
"attribute",
"of",
"rule",
"'",
"hello",
"'",
"\"",
")",
";",
"}"
] |
[
"cleanup",
":",
"close",
"the",
"stream",
",",
"close",
"the",
"fs"
] | [
"public",
"void",
"cleanup",
"(",
")",
"{",
"describe",
"(",
"\"",
"cleanup",
"\"",
")",
";",
"i",
"o",
"utils",
"close",
"stream",
"(",
"in",
")",
";",
"if",
"(",
"in",
"!",
"=",
"null",
")",
"{",
"log",
"info",
"(",
"\"",
"stream",
"statistics",
"{",
"}",
"\"",
",",
"io",
"statistics",
"source",
"to",
"string",
"(",
"in",
")",
")",
";",
"iostats",
"aggregate",
"(",
"in",
"get",
"i",
"o",
"statistics",
"(",
")",
")",
";",
"}",
"if",
"(",
"s",
"3a",
"f",
"s",
"!",
"=",
"null",
")",
"{",
"log",
"info",
"(",
"\"",
"file",
"system",
"statistics",
"{",
"}",
"\"",
",",
"io",
"statistics",
"source",
"to",
"string",
"(",
"s",
"3a",
"f",
"s",
")",
")",
";",
"filesystem",
"iostats",
"aggregate",
"(",
"s",
"3a",
"f",
"s",
"get",
"i",
"o",
"statistics",
"(",
")",
")",
";",
"i",
"o",
"utils",
"close",
"stream",
"(",
"s",
"3a",
"f",
"s",
")",
";",
"}",
"}"
] |
[
"compute",
"a",
"hash",
"code",
"using",
"the",
"hash",
"codes",
"of",
"the",
"underlying",
"objects"
] | [
"public",
"int",
"hash",
"code",
"(",
")",
"{",
"return",
"(",
"first",
"=",
"=",
"null",
"?",
"0",
":",
"first",
"hash",
"code",
"(",
")",
")",
"^",
"(",
"second",
"=",
"=",
"null",
"?",
"0",
":",
"second",
"hash",
"code",
"(",
")",
")",
";",
"}"
] |
[
"if",
"2to",
"3",
"conversion",
"is",
"to",
"be",
"done",
",",
"creates",
"the",
"2to",
"3",
"actions",
"and",
"returns",
"the",
"map",
"of",
"converted",
"files",
";",
"otherwise",
"returns",
"null",
"may",
"also",
"return",
"null",
"and",
"report",
"a",
"rule",
"error",
"if",
"there",
"is",
"a",
"problem",
"creating",
"an",
"output",
"file",
"for",
"2to",
"3",
"conversion"
] | [
"private",
"static",
"map",
"<",
"path",
"fragment",
",",
"artifact",
">",
"make",
"and",
"init",
"converted",
"files",
"(",
"rule",
"context",
"rule",
"context",
",",
"python",
"version",
"version",
",",
"python",
"version",
"sources",
"version",
")",
"{",
"if",
"(",
"sources",
"version",
"=",
"=",
"python",
"version",
"py2",
"&",
"&",
"version",
"=",
"=",
"python",
"version",
"py3",
")",
"{",
"iterable",
"<",
"artifact",
">",
"artifacts",
"=",
"rule",
"context",
"get",
"prerequisite",
"artifacts",
"(",
"\"",
"srcs",
"\"",
")",
"filter",
"(",
"py",
"rule",
"classes",
"python",
"source",
")",
"list",
"(",
")",
";",
"return",
"python",
"utils",
"generate",
"2to",
"3",
"actions",
"(",
"rule",
"context",
",",
"artifacts",
")",
";",
"}",
"else",
"{",
"return",
"null",
";",
"}",
"}"
] |
[
"returns",
"whether",
"or",
"not",
"any",
"layers",
"in",
"this",
"composition",
"has",
"masks"
] | [
"public",
"boolean",
"has",
"masks",
"(",
")",
"{",
"return",
"lottie",
"drawable",
"has",
"masks",
"(",
")",
";",
"}"
] |
[
"configure",
"whether",
"to",
"let",
"ping",
"frames",
"through",
"to",
"be",
"handled",
"by",
"the",
"{",
"@",
"link",
"web",
"socket",
"handler",
"}",
"given",
"to",
"the",
"execute",
"method",
"by",
"default",
",",
"reactor",
"netty",
"automatically",
"replies",
"with",
"pong",
"frames",
"in",
"response",
"to",
"pings",
"this",
"is",
"useful",
"in",
"a",
"proxy",
"for",
"allowing",
"ping",
"and",
"pong",
"frames",
"through",
"by",
"default",
"this",
"is",
"set",
"to",
"{",
"@",
"code",
"false",
"}",
"in",
"which",
"case",
"ping",
"frames",
"are",
"handled",
"automatically",
"by",
"reactor",
"netty",
"if",
"set",
"to",
"{",
"@",
"code",
"true",
"}",
",",
"ping",
"frames",
"will",
"be",
"passed",
"through",
"to",
"the",
"{",
"@",
"link",
"web",
"socket",
"handler",
"}"
] | [
"public",
"void",
"set",
"handle",
"ping",
"(",
"boolean",
"handle",
"ping",
")",
"{",
"this",
"handle",
"ping",
"=",
"handle",
"ping",
";",
"}"
] |
[
"adds",
"a",
"namevalue",
"pair",
"to",
"the",
"formatted",
"output",
"in",
"{",
"@",
"code",
"name",
"=",
"value",
"}",
"format"
] | [
"public",
"to",
"string",
"helper",
"add",
"(",
"string",
"name",
",",
"int",
"value",
")",
"{",
"return",
"add",
"holder",
"(",
"name",
",",
"string",
"value",
"of",
"(",
"value",
")",
")",
";",
"}"
] |
[
"waits",
"for",
"the",
"{",
"@",
"link",
"service",
"}",
"to",
"reach",
"the",
"{",
"@",
"linkplain",
"state",
"#",
"terminated",
"terminated",
"state",
"}"
] | [
"void",
"await",
"terminated",
"(",
")",
";"
] |
[
"writes",
"the",
"specified",
"end",
"element"
] | [
"public",
"void",
"end",
"element",
"(",
"string",
"name",
")",
"{",
"indent",
"level",
"-",
"-",
";",
"if",
"(",
"incomplete",
"line",
")",
"{",
"writer",
"println",
"(",
"\"",
"/",
">",
"\"",
")",
";",
"}",
"else",
"{",
"if",
"(",
"!",
"added",
"text",
")",
"{",
"indent",
"(",
")",
";",
"}",
"writer",
"println",
"(",
"\"",
"<",
"/",
"\"",
"+",
"name",
"+",
"\"",
">",
"\"",
")",
";",
"}",
"incomplete",
"line",
"=",
"false",
";",
"added",
"text",
"=",
"false",
";",
"}"
] |
[
"test",
"that",
"the",
"conversion",
"of",
"time",
"values",
"in",
"various",
"units",
"in",
"and",
"out",
"of",
"the",
"details",
"are",
"done",
"properly"
] | [
"public",
"void",
"test",
"time",
"conversion",
"(",
")",
"{",
"processing",
"details",
"details",
"=",
"new",
"processing",
"details",
"(",
"time",
"unit",
"microseconds",
")",
";",
"details",
"set",
"(",
"timing",
"enqueue",
",",
"10",
")",
";",
"assert",
"equals",
"(",
"10",
",",
"details",
"get",
"(",
"timing",
"enqueue",
")",
")",
";",
"assert",
"equals",
"(",
"10",
"000",
",",
"details",
"get",
"(",
"timing",
"enqueue",
",",
"time",
"unit",
"nanoseconds",
")",
")",
";",
"details",
"set",
"(",
"timing",
"queue",
",",
"20",
",",
"time",
"unit",
"milliseconds",
")",
";",
"details",
"add",
"(",
"timing",
"queue",
",",
"20",
",",
"time",
"unit",
"microseconds",
")",
";",
"assert",
"equals",
"(",
"20",
"020",
",",
"details",
"get",
"(",
"timing",
"queue",
")",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"details",
"get",
"(",
"timing",
"queue",
",",
"time",
"unit",
"seconds",
")",
")",
";",
"}"
] |
[
"get",
"the",
"compilation",
"info",
"of",
"the",
"router"
] | [
"string",
"get",
"compile",
"info",
"(",
")",
";"
] |
[
"notify",
"the",
"task",
"of",
"this",
"execution",
"about",
"a",
"aborted",
"checkpoint"
] | [
"public",
"void",
"notify",
"checkpoint",
"aborted",
"(",
"long",
"abort",
"checkpoint",
"id",
",",
"long",
"timestamp",
")",
"{",
"final",
"logical",
"slot",
"slot",
"=",
"assigned",
"resource",
";",
"if",
"(",
"slot",
"!",
"=",
"null",
")",
"{",
"final",
"task",
"manager",
"gateway",
"task",
"manager",
"gateway",
"=",
"slot",
"get",
"task",
"manager",
"gateway",
"(",
")",
";",
"task",
"manager",
"gateway",
"notify",
"checkpoint",
"aborted",
"(",
"attempt",
"id",
",",
"get",
"vertex",
"(",
")",
"get",
"job",
"id",
"(",
")",
",",
"abort",
"checkpoint",
"id",
",",
"timestamp",
")",
";",
"}",
"else",
"{",
"log",
"debug",
"(",
"\"",
"the",
"execution",
"has",
"no",
"slot",
"assigned",
"this",
"indicates",
"that",
"the",
"execution",
"is",
"\"",
"+",
"\"",
"no",
"longer",
"running",
"\"",
")",
";",
"}",
"}"
] |
[
"returns",
"the",
"server",
"call",
"passed",
"to",
"{",
"@",
"link",
"server",
"stream",
"tracer",
"#",
"server",
"call",
"started",
"}"
] | [
"public",
"server",
"call",
"info",
"<",
"?",
",",
"?",
">",
"get",
"server",
"call",
"info",
"(",
")",
"{",
"return",
"server",
"call",
"info",
"get",
"(",
")",
";",
"}"
] |
[
"this",
"implementation",
"determines",
"the",
"underlying",
"file",
"(",
"or",
"jar",
"file",
",",
"in",
"case",
"of",
"a",
"resource",
"in",
"a",
"jarzip",
")"
] | [
"protected",
"file",
"get",
"file",
"for",
"last",
"modified",
"check",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"url",
"url",
"=",
"get",
"u",
"r",
"l",
"(",
")",
";",
"if",
"(",
"resource",
"utils",
"is",
"jar",
"u",
"r",
"l",
"(",
"url",
")",
")",
"{",
"url",
"actual",
"url",
"=",
"resource",
"utils",
"extract",
"archive",
"u",
"r",
"l",
"(",
"url",
")",
";",
"if",
"(",
"actual",
"url",
"get",
"protocol",
"(",
")",
"starts",
"with",
"(",
"resource",
"utils",
"url",
"protocol",
"vfs",
")",
")",
"{",
"return",
"vfs",
"resource",
"delegate",
"get",
"resource",
"(",
"actual",
"url",
")",
"get",
"file",
"(",
")",
";",
"}",
"return",
"resource",
"utils",
"get",
"file",
"(",
"actual",
"url",
",",
"\"",
"jar",
"url",
"\"",
")",
";",
"}",
"else",
"{",
"return",
"get",
"file",
"(",
")",
";",
"}",
"}"
] |
[
"serializes",
"given",
"element",
"and",
"returns",
"it",
"as",
"a",
"{",
"@",
"link",
"producer",
"record",
"}"
] | [
"producer",
"record",
"<",
"byte",
"[",
"]",
",",
"byte",
"[",
"]",
">",
"serialize",
"(",
"t",
"element",
",",
"@",
"nullable",
"long",
"timestamp",
")",
";"
] |
[
"returns",
"a",
"row",
"number",
"in",
"the",
"table",
"(",
"the",
"view",
")",
"for",
"the",
"given",
"table",
"model",
"row",
"number",
"(",
"the",
"model",
")",
"the",
"given",
"value",
"is",
"the",
"<",
"b",
">",
"unfiltered",
"<",
"b",
">",
"row",
"value",
"and",
"the",
"returned",
"value",
"is",
"the",
"<",
"b",
">",
"filtered",
"<",
"b",
">",
"value",
"this",
"is",
"the",
"companion",
"method",
"to",
"{",
"@",
"link",
"#",
"get",
"model",
"row",
"(",
"int",
")",
"}"
] | [
"public",
"int",
"get",
"view",
"row",
"(",
"int",
"model",
"row",
")",
"{",
"return",
"text",
"filter",
"model",
"get",
"view",
"row",
"(",
"model",
"row",
")",
";",
"}"
] |
[
"returns",
"the",
"default",
"equivalence",
"strategy",
"used",
"to",
"compare",
"and",
"hash",
"keys",
"or",
"values",
"referenced",
"at",
"this",
"strength",
"this",
"strategy",
"will",
"be",
"used",
"unless",
"the",
"user",
"explicitly",
"specifies",
"an",
"alternate",
"strategy"
] | [
"abstract",
"equivalence",
"<",
"object",
">",
"default",
"equivalence",
"(",
")",
";"
] |
[
"called",
"when",
"the",
"original",
"composite",
"we",
"are",
"editing",
"has",
"been",
"changed"
] | [
"public",
"void",
"original",
"name",
"changed",
"(",
")",
"{",
"notify",
"(",
"original",
"listeners",
",",
"listener",
"-",
">",
"{",
"string",
"original",
"dt",
"name",
"=",
"get",
"original",
"data",
"type",
"name",
"(",
")",
";",
"listener",
"original",
"name",
"changed",
"(",
"original",
"dt",
"name",
")",
";",
"provider",
"update",
"title",
"(",
")",
";",
"}",
")",
";",
"}"
] |
[
"checks",
"for",
"editor",
"changes",
"that",
"have",
"not",
"been",
"saved",
"to",
"the",
"data",
"type",
"and",
"prompts",
"the",
"user",
"to",
"save",
"them",
"if",
"necessary",
"it",
"then",
"closes",
"the",
"editor"
] | [
"boolean",
"close",
"editor",
"(",
"editor",
"provider",
"editor",
",",
"boolean",
"allow",
"cancel",
")",
"{",
"if",
"(",
"check",
"editor",
"(",
"editor",
",",
"allow",
"cancel",
")",
")",
"{",
"dismiss",
"editor",
"(",
"editor",
")",
";",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}"
] |
[
"sets",
"the",
"<",
"code",
">",
"password",
"<",
"code",
">",
"property"
] | [
"public",
"void",
"set",
"password",
"(",
"string",
"password",
")",
"{",
"this",
"password",
"=",
"password",
";",
"}"
] |
[
"invokes",
"the",
"method",
"on",
"{",
"@",
"code",
"target",
"}",
"throws",
"an",
"error",
"if",
"the",
"method",
"is",
"not",
"supported",
"any",
"runtime",
"exception",
"thrown",
"by",
"the",
"method",
"is",
"thrown",
",",
"checked",
"exceptions",
"are",
"wrapped",
"in",
"an",
"{",
"@",
"link",
"assertion",
"error",
"}"
] | [
"public",
"object",
"invoke",
"without",
"checked",
"exception",
"(",
"t",
"target",
",",
"object",
"args",
")",
"{",
"try",
"{",
"return",
"invoke",
"(",
"target",
",",
"args",
")",
";",
"}",
"catch",
"(",
"invocation",
"target",
"exception",
"e",
")",
"{",
"throwable",
"target",
"exception",
"=",
"e",
"get",
"target",
"exception",
"(",
")",
";",
"if",
"(",
"target",
"exception",
"instanceof",
"runtime",
"exception",
")",
"{",
"throw",
"(",
"runtime",
"exception",
")",
"target",
"exception",
";",
"}",
"assertion",
"error",
"error",
"=",
"new",
"assertion",
"error",
"(",
"\"",
"unexpected",
"exception",
"\"",
")",
";",
"error",
"init",
"cause",
"(",
"target",
"exception",
")",
";",
"throw",
"error",
";",
"}",
"}"
] |
[
"gets",
"the",
"default",
"message",
"indicating",
"the",
"data",
"type",
"for",
"this",
"model",
"isn",
"'",
"t",
"valid",
"at",
"the",
"indicated",
"address"
] | [
"protected",
"final",
"string",
"get",
"default",
"invalid",
"message",
"(",
")",
"{",
"return",
"get",
"name",
"(",
")",
"+",
"\"",
"data",
"type",
"at",
"\"",
"+",
"get",
"address",
"(",
")",
"+",
"\"",
"isn",
"'",
"t",
"valid",
"\"",
";",
"}"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"assert",
"that",
"the",
"test",
"observer",
"test",
"subscriber",
"terminated",
"(",
"i",
"e",
",",
"the",
"terminal",
"latch",
"reached",
"zero",
")"
] | [
"public",
"final",
"u",
"assert",
"terminated",
"(",
")",
"{",
"if",
"(",
"done",
"get",
"count",
"(",
")",
"!",
"=",
"0",
")",
"{",
"throw",
"fail",
"(",
"\"",
"subscriber",
"still",
"running",
"!",
"\"",
")",
";",
"}",
"long",
"c",
"=",
"completions",
";",
"if",
"(",
"c",
">",
"1",
")",
"{",
"throw",
"fail",
"(",
"\"",
"terminated",
"with",
"multiple",
"completions",
":",
"\"",
"+",
"c",
")",
";",
"}",
"int",
"s",
"=",
"errors",
"size",
"(",
")",
";",
"if",
"(",
"s",
">",
"1",
")",
"{",
"throw",
"fail",
"(",
"\"",
"terminated",
"with",
"multiple",
"errors",
":",
"\"",
"+",
"s",
")",
";",
"}",
"if",
"(",
"c",
"!",
"=",
"0",
"&",
"&",
"s",
"!",
"=",
"0",
")",
"{",
"throw",
"fail",
"(",
"\"",
"terminated",
"with",
"multiple",
"completions",
"and",
"errors",
":",
"\"",
"+",
"c",
")",
";",
"}",
"return",
"(",
"u",
")",
"this",
";",
"}"
] |
[
"specify",
"whether",
"to",
"reobtain",
"the",
"target",
"connection",
"for",
"each",
"operation",
"performed",
"within",
"a",
"transaction",
"the",
"default",
"is",
"\"",
"false",
"\"",
"specify",
"\"",
"true",
"\"",
"to",
"reobtain",
"transactional",
"connections",
"for",
"every",
"call",
"on",
"the",
"connection",
"proxy",
";",
"this",
"is",
"advisable",
"on",
"j",
"boss",
"if",
"you",
"hold",
"on",
"to",
"a",
"connection",
"handle",
"across",
"transaction",
"boundaries",
"the",
"effect",
"of",
"this",
"setting",
"is",
"similar",
"to",
"the",
"\"",
"hibernate",
"connection",
"release",
"mode",
"\"",
"value",
"\"",
"after",
"statement",
"\""
] | [
"public",
"void",
"set",
"reobtain",
"transactional",
"connections",
"(",
"boolean",
"reobtain",
"transactional",
"connections",
")",
"{",
"this",
"reobtain",
"transactional",
"connections",
"=",
"reobtain",
"transactional",
"connections",
";",
"}"
] |
[
"return",
"true",
"if",
"this",
"inline",
"object",
"4",
"object",
"is",
"equal",
"to",
"o"
] | [
"public",
"boolean",
"equals",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"this",
"=",
"=",
"o",
")",
"{",
"return",
"true",
";",
"}",
"if",
"(",
"o",
"=",
"=",
"null",
"|",
"|",
"get",
"class",
"(",
")",
"!",
"=",
"o",
"get",
"class",
"(",
")",
")",
"{",
"return",
"false",
";",
"}",
"inline",
"object",
"4",
"inline",
"object",
"4",
"=",
"(",
"inline",
"object",
"4",
")",
"o",
";",
"return",
"objects",
"equals",
"(",
"this",
"param",
",",
"inline",
"object",
"4",
"param",
")",
"&",
"&",
"objects",
"equals",
"(",
"this",
"param",
"2",
",",
"inline",
"object",
"4",
"param",
"2",
")",
";",
"}"
] |
[
"create",
"a",
"directory"
] | [
"public",
"void",
"create",
"directory",
"(",
"path",
"path",
")",
"throws",
"i",
"o",
"exception",
"{",
"inner",
"create",
"directory",
"(",
"to",
"dir",
"path",
"(",
"path",
")",
")",
";",
"}"
] |
[
"on",
"a",
"concurrent",
"computation",
"that",
"throws",
"an",
"unchecked",
"exception",
",",
"all",
"threads",
"should",
"get",
"the",
"(",
"wrapped",
")",
"exception",
",",
"with",
"the",
"loader",
"called",
"only",
"once",
"the",
"result",
"should",
"not",
"be",
"cached",
"(",
"a",
"later",
"request",
"should",
"call",
"the",
"loader",
"again",
")"
] | [
"private",
"static",
"void",
"test",
"concurrent",
"loading",
"unchecked",
"exception",
"(",
"cache",
"builder",
"<",
"object",
",",
"object",
">",
"builder",
")",
"throws",
"interrupted",
"exception",
"{",
"int",
"count",
"=",
"10",
";",
"final",
"atomic",
"integer",
"call",
"count",
"=",
"new",
"atomic",
"integer",
"(",
")",
";",
"final",
"count",
"down",
"latch",
"start",
"signal",
"=",
"new",
"count",
"down",
"latch",
"(",
"count",
"+",
"1",
")",
";",
"final",
"runtime",
"exception",
"e",
"=",
"new",
"runtime",
"exception",
"(",
")",
";",
"loading",
"cache",
"<",
"string",
",",
"string",
">",
"cache",
"=",
"builder",
"build",
"(",
"new",
"cache",
"loader",
"<",
"string",
",",
"string",
">",
"(",
")",
"{",
"@",
"override",
"public",
"string",
"load",
"(",
"string",
"key",
")",
"throws",
"interrupted",
"exception",
"{",
"call",
"count",
"increment",
"and",
"get",
"(",
")",
";",
"start",
"signal",
"await",
"(",
")",
";",
"throw",
"e",
";",
"}",
"}",
")",
";",
"list",
"<",
"object",
">",
"result",
"=",
"do",
"concurrent",
"get",
"(",
"cache",
",",
"\"",
"bar",
"\"",
",",
"count",
",",
"start",
"signal",
")",
";",
"assert",
"equals",
"(",
"1",
",",
"call",
"count",
"get",
"(",
")",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"count",
";",
"i",
"+",
"+",
")",
"{",
"/",
"/",
"do",
"concurrent",
"get",
"alternates",
"between",
"calling",
"get",
"unchecked",
"and",
"calling",
"get",
",",
"but",
"an",
"unchecked",
"/",
"/",
"exception",
"thrown",
"by",
"the",
"loader",
"is",
"always",
"wrapped",
"as",
"an",
"unchecked",
"execution",
"exception",
"assert",
"that",
"(",
"result",
"get",
"(",
"i",
")",
")",
"is",
"instance",
"of",
"(",
"unchecked",
"execution",
"exception",
"class",
")",
";",
"assert",
"that",
"(",
"(",
"(",
"unchecked",
"execution",
"exception",
")",
"result",
"get",
"(",
"i",
")",
")",
")",
"has",
"cause",
"that",
"(",
")",
"is",
"same",
"instance",
"as",
"(",
"e",
")",
";",
"}",
"/",
"/",
"subsequent",
"calls",
"should",
"call",
"the",
"loader",
"again",
",",
"not",
"get",
"the",
"old",
"exception",
"try",
"{",
"cache",
"get",
"unchecked",
"(",
"\"",
"bar",
"\"",
")",
";",
"fail",
"(",
")",
";",
"}",
"catch",
"(",
"unchecked",
"execution",
"exception",
"expected",
")",
"{",
"}",
"assert",
"equals",
"(",
"2",
",",
"call",
"count",
"get",
"(",
")",
")",
";",
"}"
] |
[
"return",
"a",
"new",
"{",
"@",
"code",
"handler",
"strategies",
"}",
"with",
"default",
"initialization"
] | [
"static",
"handler",
"strategies",
"with",
"defaults",
"(",
")",
"{",
"return",
"builder",
"(",
")",
"build",
"(",
")",
";",
"}"
] |
[
"gets",
"the",
"event",
"'",
"s",
"source",
"address"
] | [
"public",
"int",
"source",
"address",
"(",
")",
"{",
"return",
"source",
"address",
";",
"}"
] |
[
"creates",
"the",
"{",
"@",
"code",
"m",
"bean",
"server",
"}",
"instance"
] | [
"public",
"void",
"after",
"properties",
"set",
"(",
")",
"throws",
"m",
"bean",
"server",
"not",
"found",
"exception",
"{",
"/",
"/",
"try",
"to",
"locate",
"existing",
"m",
"bean",
"server",
",",
"if",
"desired",
"if",
"(",
"this",
"locate",
"existing",
"server",
"if",
"possible",
"|",
"|",
"this",
"agent",
"id",
"!",
"=",
"null",
")",
"{",
"try",
"{",
"this",
"server",
"=",
"locate",
"m",
"bean",
"server",
"(",
"this",
"agent",
"id",
")",
";",
"}",
"catch",
"(",
"m",
"bean",
"server",
"not",
"found",
"exception",
"ex",
")",
"{",
"/",
"/",
"if",
"agent",
"id",
"was",
"specified",
",",
"we",
"were",
"only",
"supposed",
"to",
"locate",
"that",
"/",
"/",
"specific",
"m",
"bean",
"server",
";",
"so",
"let",
"'",
"s",
"bail",
"if",
"we",
"can",
"'",
"t",
"find",
"it",
"if",
"(",
"this",
"agent",
"id",
"!",
"=",
"null",
")",
"{",
"throw",
"ex",
";",
"}",
"logger",
"debug",
"(",
"\"",
"no",
"existing",
"m",
"bean",
"server",
"found",
"-",
"creating",
"new",
"one",
"\"",
")",
";",
"}",
"}",
"/",
"/",
"create",
"a",
"new",
"m",
"bean",
"server",
"and",
"register",
"it",
",",
"if",
"desired",
"if",
"(",
"this",
"server",
"=",
"=",
"null",
")",
"{",
"this",
"server",
"=",
"create",
"m",
"bean",
"server",
"(",
"this",
"default",
"domain",
",",
"this",
"register",
"with",
"factory",
")",
";",
"this",
"newly",
"registered",
"=",
"this",
"register",
"with",
"factory",
";",
"}",
"}"
] |
[
"write",
"a",
"{",
"@",
"link",
"point",
"}",
"into",
"influx",
"d",
"b",
"note",
"that",
",",
"the",
"{",
"@",
"link",
"point",
"}",
"is",
"written",
"into",
"buffer",
"of",
"influx",
"d",
"b",
"client",
"and",
"wait",
"for",
"buffer",
"flushing"
] | [
"public",
"void",
"write",
"(",
"point",
"point",
")",
"{",
"try",
"{",
"get",
"influx",
"(",
")",
"write",
"(",
"point",
")",
";",
"this",
"health",
"checker",
"health",
"(",
")",
";",
"}",
"catch",
"(",
"throwable",
"e",
")",
"{",
"health",
"checker",
"un",
"health",
"(",
"e",
")",
";",
"throw",
"e",
";",
"}",
"}"
] |
[
"throws",
"the",
"right",
"exception",
"when",
"an",
"attribute",
"has",
"an",
"unexpected",
"length",
"(",
"given",
"its",
"contents",
")"
] | [
"private",
"static",
"attribute",
"throw",
"bad",
"length",
"(",
"int",
"expected",
")",
"{",
"throw",
"new",
"parse",
"exception",
"(",
"\"",
"bad",
"attribute",
"length",
";",
"expected",
"length",
"\"",
"+",
"hex",
"u",
"4",
"(",
"expected",
")",
")",
";",
"}"
] |
[
"returns",
"the",
"start",
"of",
"the",
"token",
"that",
"ends",
"at",
"offset",
"<",
"code",
">",
"cursor",
"<",
"code",
">",
"within",
"<",
"code",
">",
"text",
"<",
"code",
">",
"it",
"is",
"a",
"method",
"from",
"the",
"multi",
"auto",
"complete",
"text",
"view",
"tokenizer",
"interface"
] | [
"public",
"int",
"find",
"token",
"start",
"(",
"char",
"sequence",
"text",
",",
"int",
"cursor",
")",
"{",
"int",
"i",
"=",
"cursor",
";",
"char",
"c",
";",
"while",
"(",
"i",
">",
"0",
"&",
"&",
"(",
"c",
"=",
"text",
"char",
"at",
"(",
"i",
"-",
"1",
")",
")",
"!",
"=",
"'",
",",
"'",
"&",
"&",
"c",
"!",
"=",
"'",
";",
"'",
")",
"{",
"i",
"-",
"-",
";",
"}",
"while",
"(",
"i",
"<",
"cursor",
"&",
"&",
"text",
"char",
"at",
"(",
"i",
")",
"=",
"=",
"'",
"'",
")",
"{",
"i",
"+",
"+",
";",
"}",
"return",
"i",
";",
"}"
] |
[
"replace",
"any",
"subtree",
"siblings",
"of",
"root",
"that",
"are",
"completely",
"to",
"left",
"or",
"right",
"of",
"lookahead",
"range",
"with",
"a",
"common",
"token",
"(",
"token",
"invalid",
"type",
",",
"\"",
"\"",
")",
"node",
"the",
"source",
"interval",
"for",
"t",
"is",
"not",
"altered",
"to",
"suit",
"smaller",
"range",
"!",
"warning",
":",
"destructive",
"to",
"t"
] | [
"public",
"static",
"void",
"strip",
"children",
"out",
"of",
"range",
"(",
"parser",
"rule",
"context",
"t",
",",
"parser",
"rule",
"context",
"root",
",",
"int",
"start",
"index",
",",
"int",
"stop",
"index",
")",
"{",
"if",
"(",
"t",
"=",
"=",
"null",
")",
"return",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"t",
"get",
"child",
"count",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"parse",
"tree",
"child",
"=",
"t",
"get",
"child",
"(",
"i",
")",
";",
"interval",
"range",
"=",
"child",
"get",
"source",
"interval",
"(",
")",
";",
"if",
"(",
"child",
"instanceof",
"parser",
"rule",
"context",
"&",
"&",
"(",
"range",
"b",
"<",
"start",
"index",
"|",
"|",
"range",
"a",
">",
"stop",
"index",
")",
")",
"{",
"if",
"(",
"is",
"ancestor",
"of",
"(",
"child",
",",
"root",
")",
")",
"{",
"/",
"/",
"replace",
"only",
"if",
"subtree",
"doesn",
"'",
"t",
"have",
"displayed",
"root",
"common",
"token",
"abbrev",
"=",
"new",
"common",
"token",
"(",
"token",
"invalid",
"type",
",",
"\"",
"\"",
")",
";",
"t",
"children",
"set",
"(",
"i",
",",
"new",
"terminal",
"node",
"impl",
"(",
"abbrev",
")",
")",
";",
"}",
"}",
"}",
"}"
] |
[
"searches",
"the",
"hash",
"table",
"for",
"a",
"record",
"with",
"the",
"given",
"key",
"if",
"it",
"is",
"found",
",",
"then",
"it",
"is",
"overridden",
"with",
"the",
"specified",
"record",
"otherwise",
",",
"the",
"specified",
"record",
"is",
"inserted"
] | [
"public",
"void",
"insert",
"or",
"replace",
"record",
"(",
"t",
"record",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"closed",
")",
"{",
"return",
";",
"}",
"t",
"match",
"=",
"prober",
"get",
"match",
"for",
"(",
"record",
",",
"reuse",
")",
";",
"if",
"(",
"match",
"=",
"=",
"null",
")",
"{",
"prober",
"insert",
"after",
"no",
"match",
"(",
"record",
")",
";",
"}",
"else",
"{",
"prober",
"update",
"match",
"(",
"record",
")",
";",
"}",
"}"
] |
[
"set",
"whether",
"the",
"sql",
"can",
"be",
"used",
"as",
"is"
] | [
"public",
"void",
"set",
"sql",
"ready",
"for",
"use",
"(",
"boolean",
"sql",
"ready",
"for",
"use",
")",
"{",
"this",
"sql",
"ready",
"for",
"use",
"=",
"sql",
"ready",
"for",
"use",
";",
"}"
] |
[
"override",
"this",
"to",
"perform",
"actions",
"before",
"the",
"call",
"{",
"@",
"code",
"actual",
"on",
"subscribe",
"(",
"this",
")",
"}",
"happens"
] | [
"protected",
"boolean",
"before",
"downstream",
"(",
")",
"{",
"return",
"true",
";",
"}"
] |
[
"if",
"the",
"operation",
"was",
"aborted",
"due",
"to",
"missing",
"mappings",
",",
"this",
"method",
"will",
"return",
"the",
"mappings",
"that",
"are",
"required",
"to",
"complete",
"the",
"operation"
] | [
"public",
"mapping",
"get",
"required",
"mapping",
"update",
"(",
")",
"{",
"return",
"required",
"mapping",
"update",
";",
"}"
] |
[
"ensures",
"this",
"big",
"array",
"is",
"at",
"least",
"the",
"specified",
"length",
"if",
"the",
"array",
"is",
"smaller",
",",
"segments",
"are",
"added",
"until",
"the",
"array",
"is",
"larger",
"then",
"the",
"specified",
"length"
] | [
"public",
"void",
"ensure",
"capacity",
"(",
"long",
"length",
")",
"{",
"if",
"(",
"capacity",
">",
"length",
")",
"{",
"return",
";",
"}",
"grow",
"(",
"length",
")",
";",
"}"
] |
[
"creates",
"a",
"test",
"attempt",
"result",
"instance",
"for",
"a",
"test",
"that",
"was",
"not",
"locally",
"cached",
";",
"it",
"may",
"have",
"been",
"locally",
"executed",
",",
"remotely",
"executed",
",",
"or",
"remotely",
"cached"
] | [
"public",
"static",
"test",
"attempt",
"for",
"executed",
"test",
"result",
"(",
"test",
"runner",
"action",
"test",
"action",
",",
"test",
"result",
"data",
"attempt",
"data",
",",
"int",
"attempt",
",",
"collection",
"<",
"pair",
"<",
"string",
",",
"path",
">",
">",
"files",
",",
"build",
"event",
"stream",
"protos",
"test",
"result",
"execution",
"info",
"execution",
"info",
",",
"boolean",
"last",
"attempt",
")",
"{",
"return",
"new",
"test",
"attempt",
"(",
"false",
",",
"test",
"action",
",",
"execution",
"info",
",",
"attempt",
",",
"attempt",
"data",
"get",
"status",
"(",
")",
",",
"attempt",
"data",
"get",
"status",
"details",
"(",
")",
",",
"attempt",
"data",
"get",
"start",
"time",
"millis",
"epoch",
"(",
")",
",",
"attempt",
"data",
"get",
"run",
"duration",
"millis",
"(",
")",
",",
"files",
",",
"attempt",
"data",
"get",
"warning",
"list",
"(",
")",
",",
"last",
"attempt",
")",
";",
"}"
] |
[
"create",
"a",
"new",
"resource",
"by",
"p",
"o",
"s",
"ting",
"the",
"given",
"object",
"to",
"the",
"url",
",",
"and",
"returns",
"the",
"value",
"of",
"the",
"{",
"@",
"code",
"location",
"}",
"header",
"this",
"header",
"typically",
"indicates",
"where",
"the",
"new",
"resource",
"is",
"stored",
"the",
"{",
"@",
"code",
"request",
"}",
"parameter",
"can",
"be",
"a",
"{",
"@",
"link",
"http",
"entity",
"}",
"in",
"order",
"to",
"add",
"additional",
"http",
"headers",
"to",
"the",
"request",
"the",
"body",
"of",
"the",
"entity",
",",
"or",
"{",
"@",
"code",
"request",
"}",
"itself",
",",
"can",
"be",
"a",
"{",
"@",
"link",
"org",
"springframework",
"util",
"multi",
"value",
"map",
"multi",
"value",
"map",
"}",
"to",
"create",
"a",
"multipart",
"request",
"the",
"values",
"in",
"the",
"{",
"@",
"code",
"multi",
"value",
"map",
"}",
"can",
"be",
"any",
"object",
"representing",
"the",
"body",
"of",
"the",
"part",
",",
"or",
"an",
"{",
"@",
"link",
"org",
"springframework",
"http",
"http",
"entity",
"http",
"entity",
"}",
"representing",
"a",
"part",
"with",
"body",
"and",
"headers"
] | [
"uri",
"post",
"for",
"location",
"(",
"uri",
"url",
",",
"@",
"nullable",
"object",
"request",
")",
"throws",
"rest",
"client",
"exception",
";"
] |
[
"warning",
":",
"drops",
"all",
"table",
"on",
"upgrade",
"!",
"use",
"only",
"during",
"development",
"convenience",
"method",
"using",
"a",
"{",
"@",
"link",
"dev",
"open",
"helper",
"}"
] | [
"public",
"static",
"dao",
"session",
"new",
"dev",
"session",
"(",
"context",
"context",
",",
"string",
"name",
")",
"{",
"database",
"db",
"=",
"new",
"dev",
"open",
"helper",
"(",
"context",
",",
"name",
")",
"get",
"writable",
"db",
"(",
")",
";",
"dao",
"master",
"dao",
"master",
"=",
"new",
"dao",
"master",
"(",
"db",
")",
";",
"return",
"dao",
"master",
"new",
"session",
"(",
")",
";",
"}"
] |
[
"indicates",
"whether",
"or",
"not",
"this",
"map",
"contains",
"a",
"value",
"for",
"the",
"specified",
"key"
] | [
"boolean",
"contains",
"key",
"(",
"long",
"key",
")",
";"
] |
[
"decode",
"a",
"{",
"@",
"link",
"data",
"buffer",
"}",
"input",
"stream",
"into",
"a",
"mono",
"of",
"{",
"@",
"code",
"t",
"}"
] | [
"mono",
"<",
"t",
">",
"decode",
"to",
"mono",
"(",
"publisher",
"<",
"data",
"buffer",
">",
"input",
"stream",
",",
"resolvable",
"type",
"element",
"type",
",",
"@",
"nullable",
"mime",
"type",
"mime",
"type",
",",
"@",
"nullable",
"map",
"<",
"string",
",",
"object",
">",
"hints",
")",
";"
] |
[
"test",
"serialization",
"of",
"outer",
"number",
"types",
"<",
"b",
">",
"200",
"<",
"b",
">",
"-",
"output",
"number"
] | [
"public",
"mono",
"<",
"big",
"decimal",
">",
"fake",
"outer",
"number",
"serialize",
"(",
"big",
"decimal",
"body",
")",
"throws",
"web",
"client",
"response",
"exception",
"{",
"object",
"post",
"body",
"=",
"body",
";",
"/",
"/",
"create",
"path",
"and",
"map",
"variables",
"final",
"map",
"<",
"string",
",",
"object",
">",
"path",
"params",
"=",
"new",
"hash",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"final",
"multi",
"value",
"map",
"<",
"string",
",",
"string",
">",
"query",
"params",
"=",
"new",
"linked",
"multi",
"value",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"final",
"http",
"headers",
"header",
"params",
"=",
"new",
"http",
"headers",
"(",
")",
";",
"final",
"multi",
"value",
"map",
"<",
"string",
",",
"string",
">",
"cookie",
"params",
"=",
"new",
"linked",
"multi",
"value",
"map",
"<",
"string",
",",
"string",
">",
"(",
")",
";",
"final",
"multi",
"value",
"map",
"<",
"string",
",",
"object",
">",
"form",
"params",
"=",
"new",
"linked",
"multi",
"value",
"map",
"<",
"string",
",",
"object",
">",
"(",
")",
";",
"final",
"string",
"[",
"]",
"local",
"var",
"accepts",
"=",
"{",
"\"",
"*",
"/",
"*",
"\"",
"}",
";",
"final",
"list",
"<",
"media",
"type",
">",
"local",
"var",
"accept",
"=",
"api",
"client",
"select",
"header",
"accept",
"(",
"local",
"var",
"accepts",
")",
";",
"final",
"string",
"[",
"]",
"local",
"var",
"content",
"types",
"=",
"{",
"}",
";",
"final",
"media",
"type",
"local",
"var",
"content",
"type",
"=",
"api",
"client",
"select",
"header",
"content",
"type",
"(",
"local",
"var",
"content",
"types",
")",
";",
"string",
"[",
"]",
"local",
"var",
"auth",
"names",
"=",
"new",
"string",
"[",
"]",
"{",
"}",
";",
"parameterized",
"type",
"reference",
"<",
"big",
"decimal",
">",
"local",
"var",
"return",
"type",
"=",
"new",
"parameterized",
"type",
"reference",
"<",
"big",
"decimal",
">",
"(",
")",
"{",
"}",
";",
"return",
"api",
"client",
"invoke",
"a",
"p",
"i",
"(",
"\"",
"/",
"fake",
"/",
"outer",
"/",
"number",
"\"",
",",
"http",
"method",
"post",
",",
"path",
"params",
",",
"query",
"params",
",",
"post",
"body",
",",
"header",
"params",
",",
"cookie",
"params",
",",
"form",
"params",
",",
"local",
"var",
"accept",
",",
"local",
"var",
"content",
"type",
",",
"local",
"var",
"auth",
"names",
",",
"local",
"var",
"return",
"type",
")",
";",
"}"
] |
[
"a",
"human",
"-",
"readable",
"description",
"of",
"the",
"implementation"
] | [
"string",
"to",
"string",
"(",
")",
";"
] |
[
"get",
"and",
"set",
"returns",
"previous",
"value",
"and",
"sets",
"to",
"given",
"value",
"at",
"given",
"index"
] | [
"public",
"void",
"test",
"get",
"and",
"set",
"(",
")",
"{",
"atomic",
"double",
"array",
"aa",
"=",
"new",
"atomic",
"double",
"array",
"(",
"size",
")",
";",
"for",
"(",
"int",
"i",
":",
"new",
"int",
"[",
"]",
"{",
"0",
",",
"size",
"-",
"1",
"}",
")",
"{",
"double",
"prev",
"=",
"0",
"0",
";",
"for",
"(",
"double",
"x",
":",
"values",
")",
"{",
"assert",
"bit",
"equals",
"(",
"prev",
",",
"aa",
"get",
"and",
"set",
"(",
"i",
",",
"x",
")",
")",
";",
"prev",
"=",
"x",
";",
"}",
"}",
"}"
] |
[
"perform",
"a",
"number",
"on",
"assertions",
"and",
"checks",
"on",
"{",
"@",
"link",
"org",
"elasticsearch",
"common",
"rounding",
"time",
"unit",
"rounding",
"}",
"intervals"
] | [
"private",
"void",
"assert",
"interval",
"(",
"long",
"rounded",
",",
"long",
"unrounded",
",",
"long",
"next",
"rounding",
"value",
",",
"rounding",
"rounding",
",",
"zone",
"id",
"tz",
")",
"{",
"assert",
"that",
"(",
"\"",
"rounding",
"should",
"be",
"idempotent",
"\"",
",",
"rounding",
"round",
"(",
"rounded",
")",
",",
"is",
"date",
"(",
"rounded",
",",
"tz",
")",
")",
";",
"assert",
"that",
"(",
"\"",
"rounded",
"value",
"smaller",
"or",
"equal",
"than",
"unrounded",
"\"",
",",
"rounded",
",",
"less",
"than",
"or",
"equal",
"to",
"(",
"unrounded",
")",
")",
";",
"assert",
"that",
"(",
"\"",
"values",
"less",
"than",
"rounded",
"should",
"round",
"further",
"down",
"\"",
",",
"rounding",
"round",
"(",
"rounded",
"-",
"1",
")",
",",
"less",
"than",
"(",
"rounded",
")",
")",
";",
"assert",
"that",
"(",
"\"",
"next",
"rounding",
"value",
"should",
"be",
"a",
"rounded",
"date",
"\"",
",",
"rounding",
"round",
"(",
"next",
"rounding",
"value",
")",
",",
"is",
"date",
"(",
"next",
"rounding",
"value",
",",
"tz",
")",
")",
";",
"assert",
"that",
"(",
"\"",
"values",
"above",
"next",
"rounding",
"should",
"round",
"down",
"there",
"\"",
",",
"rounding",
"round",
"(",
"next",
"rounding",
"value",
"+",
"1",
")",
",",
"is",
"date",
"(",
"next",
"rounding",
"value",
",",
"tz",
")",
")",
";",
"if",
"(",
"is",
"time",
"with",
"well",
"defined",
"rounding",
"(",
"tz",
",",
"unrounded",
")",
")",
"{",
"assert",
"that",
"(",
"\"",
"next",
"rounding",
"value",
"should",
"be",
"greater",
"than",
"date",
"\"",
"+",
"rounding",
",",
"next",
"rounding",
"value",
",",
"greater",
"than",
"(",
"unrounded",
")",
")",
";",
"long",
"date",
"between",
"=",
"date",
"between",
"(",
"rounded",
",",
"next",
"rounding",
"value",
")",
";",
"long",
"rounding",
"date",
"between",
"=",
"rounding",
"round",
"(",
"date",
"between",
")",
";",
"zoned",
"date",
"time",
"zoned",
"date",
"between",
"=",
"zoned",
"date",
"time",
"of",
"instant",
"(",
"instant",
"of",
"epoch",
"milli",
"(",
"date",
"between",
")",
",",
"tz",
")",
";",
"assert",
"that",
"(",
"\"",
"date",
"between",
"[",
"\"",
"+",
"zoned",
"date",
"between",
"+",
"\"",
"/",
"\"",
"+",
"date",
"between",
"+",
"\"",
"]",
"should",
"round",
"down",
"to",
"rounded",
"date",
"[",
"\"",
"+",
"instant",
"of",
"epoch",
"milli",
"(",
"rounding",
"date",
"between",
")",
"+",
"\"",
"]",
"\"",
",",
"rounding",
"date",
"between",
",",
"is",
"date",
"(",
"rounded",
",",
"tz",
")",
")",
";",
"assert",
"that",
"(",
"\"",
"date",
"between",
"[",
"\"",
"+",
"zoned",
"date",
"between",
"+",
"\"",
"]",
"should",
"round",
"up",
"to",
"next",
"rounding",
"value",
"\"",
",",
"rounding",
"next",
"rounding",
"value",
"(",
"date",
"between",
")",
",",
"is",
"date",
"(",
"next",
"rounding",
"value",
",",
"tz",
")",
")",
";",
"}",
"}"
] |
[
"creates",
"a",
"new",
"transform",
"asynchronously",
"and",
"notifies",
"listener",
"on",
"completion",
"for",
"additional",
"info",
"see",
"<",
"a",
"href",
"=",
"\"",
"https",
":",
"www",
"elastic",
"coguideenelasticsearchreferencecurrentput",
"-",
"transform",
"html",
"\"",
">",
"create",
"transform",
"documentation"
] | [
"public",
"cancellable",
"put",
"transform",
"async",
"(",
"put",
"transform",
"request",
"request",
",",
"request",
"options",
"options",
",",
"action",
"listener",
"<",
"acknowledged",
"response",
">",
"listener",
")",
"{",
"return",
"rest",
"high",
"level",
"client",
"perform",
"request",
"async",
"and",
"parse",
"entity",
"(",
"request",
",",
"transform",
"request",
"converters",
":",
":",
"put",
"transform",
",",
"options",
",",
"acknowledged",
"response",
":",
":",
"from",
"x",
"content",
",",
"listener",
",",
"collections",
"empty",
"set",
"(",
")",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"bool",
"item",
"'"
] | [
"public",
"void",
"bool",
"item",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"bool",
"item",
"}"
] |
[
"map",
"the",
"route",
"for",
"http",
"trace",
"requests"
] | [
"public",
"void",
"trace",
"(",
"string",
"path",
",",
"route",
"route",
",",
"response",
"transformer",
"transformer",
")",
"{",
"add",
"route",
"(",
"http",
"method",
"trace",
",",
"response",
"transformer",
"route",
"impl",
"create",
"(",
"path",
",",
"route",
",",
"transformer",
")",
")",
";",
"}"
] |
[
"test",
"filtering",
"two",
"int",
"points"
] | [
"public",
"void",
"test",
"points",
"(",
")",
"throws",
"exception",
"{",
"directory",
"dir",
"=",
"new",
"directory",
"(",
")",
";",
"index",
"writer",
"config",
"iwc",
"=",
"new",
"index",
"writer",
"config",
"(",
"null",
")",
";",
"index",
"writer",
"iw",
"=",
"new",
"index",
"writer",
"(",
"dir",
",",
"iwc",
")",
";",
"/",
"/",
"add",
"document",
"with",
"2",
"points",
"document",
"doc",
"=",
"new",
"document",
"(",
")",
";",
"doc",
"add",
"(",
"new",
"int",
"point",
"(",
"\"",
"field",
"a",
"\"",
",",
"1",
")",
")",
";",
"doc",
"add",
"(",
"new",
"int",
"point",
"(",
"\"",
"field",
"b",
"\"",
",",
"2",
")",
")",
";",
"iw",
"add",
"document",
"(",
"doc",
")",
";",
"/",
"/",
"open",
"reader",
"directory",
"reader",
"ir",
"=",
"field",
"subset",
"reader",
"wrap",
"(",
"directory",
"reader",
"open",
"(",
"iw",
")",
",",
"new",
"character",
"run",
"automaton",
"(",
"automata",
"make",
"string",
"(",
"\"",
"field",
"a",
"\"",
")",
")",
")",
";",
"/",
"/",
"see",
"only",
"one",
"field",
"leaf",
"reader",
"segment",
"reader",
"=",
"ir",
"leaves",
"(",
")",
"get",
"(",
"0",
")",
"reader",
"(",
")",
";",
"point",
"values",
"points",
"=",
"segment",
"reader",
"get",
"point",
"values",
"(",
"\"",
"field",
"a",
"\"",
")",
";",
"assert",
"null",
"(",
"segment",
"reader",
"get",
"point",
"values",
"(",
"\"",
"field",
"b",
"\"",
")",
")",
";",
"/",
"/",
"size",
"statistic",
"assert",
"equals",
"(",
"1",
",",
"points",
"size",
"(",
")",
")",
";",
"/",
"/",
"doccount",
"statistic",
"assert",
"equals",
"(",
"1",
",",
"points",
"get",
"doc",
"count",
"(",
")",
")",
";",
"/",
"/",
"min",
"statistic",
"assert",
"not",
"null",
"(",
"points",
"get",
"min",
"packed",
"value",
"(",
")",
")",
";",
"/",
"/",
"max",
"statistic",
"assert",
"not",
"null",
"(",
"points",
"get",
"max",
"packed",
"value",
"(",
")",
")",
";",
"/",
"/",
"bytes",
"per",
"dimension",
"assert",
"equals",
"(",
"integer",
"bytes",
",",
"points",
"get",
"bytes",
"per",
"dimension",
"(",
")",
")",
";",
"/",
"/",
"number",
"of",
"dimensions",
"assert",
"equals",
"(",
"1",
",",
"points",
"get",
"num",
"index",
"dimensions",
"(",
")",
")",
";",
"/",
"/",
"walk",
"the",
"trees",
":",
"we",
"should",
"see",
"stuff",
"in",
"field",
"a",
"atomic",
"boolean",
"saw",
"doc",
"=",
"new",
"atomic",
"boolean",
"(",
"false",
")",
";",
"points",
"intersect",
"(",
"new",
"intersect",
"visitor",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"visit",
"(",
"int",
"doc",
"i",
"d",
")",
"throws",
"i",
"o",
"exception",
"{",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"should",
"not",
"get",
"here",
"\"",
")",
";",
"}",
"@",
"override",
"public",
"void",
"visit",
"(",
"int",
"doc",
"i",
"d",
",",
"byte",
"[",
"]",
"packed",
"value",
")",
"throws",
"i",
"o",
"exception",
"{",
"saw",
"doc",
"set",
"(",
"true",
")",
";",
"}",
"@",
"override",
"public",
"relation",
"compare",
"(",
"byte",
"[",
"]",
"min",
"packed",
"value",
",",
"byte",
"[",
"]",
"max",
"packed",
"value",
")",
"{",
"return",
"relation",
"cell",
"crosses",
"query",
";",
"}",
"}",
")",
";",
"assert",
"true",
"(",
"saw",
"doc",
"get",
"(",
")",
")",
";",
"test",
"util",
"check",
"reader",
"(",
"ir",
")",
";",
"i",
"o",
"utils",
"close",
"(",
"ir",
",",
"iw",
",",
"dir",
")",
";",
"}"
] |
[
"set",
"the",
"user",
"-",
"agent",
"header",
"'",
"s",
"value",
"(",
"by",
"adding",
"to",
"the",
"default",
"header",
"map",
")"
] | [
"public",
"api",
"client",
"set",
"user",
"agent",
"(",
"string",
"user",
"agent",
")",
"{",
"user",
"agent",
"=",
"user",
"agent",
";",
"add",
"default",
"header",
"(",
"\"",
"user",
"-",
"agent",
"\"",
",",
"user",
"agent",
")",
";",
"return",
"this",
";",
"}"
] |
[
"updated",
"user",
"this",
"can",
"only",
"be",
"done",
"by",
"the",
"logged",
"in",
"user"
] | [
"public",
"void",
"update",
"user",
"(",
"@",
"path",
"param",
"(",
"\"",
"username",
"\"",
")",
"string",
"username",
",",
"user",
"body",
")",
";"
] |
[
"only",
"create",
"a",
"stream",
"table",
"source"
] | [
"default",
"table",
"source",
"<",
"t",
">",
"create",
"table",
"source",
"(",
"map",
"<",
"string",
",",
"string",
">",
"properties",
")",
"{",
"stream",
"table",
"source",
"<",
"t",
">",
"source",
"=",
"create",
"stream",
"table",
"source",
"(",
"properties",
")",
";",
"if",
"(",
"source",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"validation",
"exception",
"(",
"\"",
"please",
"override",
"'",
"create",
"table",
"source",
"(",
"context",
")",
"'",
"method",
"\"",
")",
";",
"}",
"return",
"source",
";",
"}"
] |
[
"creates",
"a",
"channel",
"with",
"a",
"target",
"string",
",",
"which",
"can",
"be",
"either",
"a",
"valid",
"{",
"@",
"link",
"name",
"resolver",
"}",
"-",
"compliant",
"uri",
",",
"or",
"an",
"authority",
"string",
"a",
"{",
"@",
"code",
"name",
"resolver",
"}",
"-",
"compliant",
"uri",
"is",
"an",
"absolute",
"hierarchical",
"uri",
"as",
"defined",
"by",
"{",
"@",
"link",
"java",
"net",
"uri",
"}",
"example",
"u",
"r",
"is",
":",
"{",
"@",
"code",
"\"",
"dns",
":",
"foo",
"googleapis",
"com",
":",
"8080",
"\"",
"}",
"{",
"@",
"code",
"\"",
"dns",
":",
"foo",
"googleapis",
"com",
"\"",
"}",
"{",
"@",
"code",
"\"",
"dns",
":",
"%",
"5b2001",
":",
"db",
"8",
":",
"8",
"5a",
"3",
":",
"8d",
"3",
":",
"1319",
":",
"8a",
"2e",
":",
"370",
":",
"7348",
"%",
"5d",
":",
"443",
"\"",
"}",
"{",
"@",
"code",
"\"",
"dns",
":",
"8",
"8",
"8",
"8foo",
"googleapis",
"com",
":",
"8080",
"\"",
"}",
"{",
"@",
"code",
"\"",
"dns",
":",
"8",
"8",
"8",
"8foo",
"googleapis",
"com",
"\"",
"}",
"{",
"@",
"code",
"\"",
"zookeeper",
":",
"zk",
"example",
"com",
":",
"9",
"9",
"0",
"0example",
"service",
"\"",
"}",
"an",
"authority",
"string",
"will",
"be",
"converted",
"to",
"a",
"{",
"@",
"code",
"name",
"resolver",
"}",
"-",
"compliant",
"uri",
",",
"which",
"has",
"the",
"scheme",
"from",
"the",
"name",
"resolver",
"with",
"the",
"highest",
"priority",
"(",
"e",
"g",
"{",
"@",
"code",
"\"",
"dns",
"\"",
"}",
")",
",",
"no",
"authority",
",",
"and",
"the",
"original",
"authority",
"string",
"as",
"its",
"path",
"after",
"properly",
"escaped",
"we",
"recommend",
"libraries",
"to",
"specify",
"the",
"schema",
"explicitly",
"if",
"it",
"is",
"known",
",",
"since",
"libraries",
"cannot",
"know",
"which",
"name",
"resolver",
"will",
"be",
"default",
"during",
"runtime",
"example",
"authority",
"strings",
":",
"{",
"@",
"code",
"\"",
"localhost",
"\"",
"}",
"{",
"@",
"code",
"\"",
"127",
"0",
"0",
"1",
"\"",
"}",
"{",
"@",
"code",
"\"",
"localhost",
":",
"8080",
"\"",
"}",
"{",
"@",
"code",
"\"",
"foo",
"googleapis",
"com",
":",
"8080",
"\"",
"}",
"{",
"@",
"code",
"\"",
"127",
"0",
"0",
"1",
":",
"8080",
"\"",
"}",
"{",
"@",
"code",
"\"",
"[",
"2001",
":",
"db",
"8",
":",
"8",
"5a",
"3",
":",
"8d",
"3",
":",
"1319",
":",
"8a",
"2e",
":",
"370",
":",
"7348",
"]",
"\"",
"}",
"{",
"@",
"code",
"\"",
"[",
"2001",
":",
"db",
"8",
":",
"8",
"5a",
"3",
":",
"8d",
"3",
":",
"1319",
":",
"8a",
"2e",
":",
"370",
":",
"7348",
"]",
":",
"443",
"\"",
"}"
] | [
"public",
"static",
"managed",
"channel",
"builder",
"<",
"?",
">",
"for",
"target",
"(",
"string",
"target",
")",
"{",
"return",
"managed",
"channel",
"provider",
"provider",
"(",
")",
"builder",
"for",
"target",
"(",
"target",
")",
";",
"}"
] |
[
"this",
"helper",
"function",
"is",
"needed",
"to",
"check",
"that",
"the",
"temporary",
"fix",
"for",
"flink",
"-",
"13063",
"can",
"be",
"backwards",
"compatible",
"with",
"the",
"old",
"chaining",
"behavior",
"by",
"setting",
"the",
"chaining",
"strategy",
"manually",
"todo",
":",
"remove",
"after",
"a",
"proper",
"fix",
"for",
"flink",
"-",
"13063",
"is",
"in",
"place",
"that",
"allows",
"chaining"
] | [
"private",
"<",
"in",
",",
"out",
">",
"single",
"output",
"stream",
"operator",
"<",
"out",
">",
"add",
"async",
"operator",
"legacy",
"chained",
"(",
"data",
"stream",
"<",
"in",
">",
"in",
",",
"async",
"function",
"<",
"in",
",",
"out",
">",
"func",
",",
"long",
"timeout",
",",
"int",
"buf",
"size",
",",
"async",
"data",
"stream",
"output",
"mode",
"mode",
")",
"{",
"type",
"information",
"<",
"out",
">",
"out",
"type",
"info",
"=",
"type",
"extractor",
"get",
"unary",
"operator",
"return",
"type",
"(",
"func",
",",
"async",
"function",
"class",
",",
"0",
",",
"1",
",",
"new",
"int",
"[",
"]",
"{",
"1",
",",
"0",
"}",
",",
"in",
"get",
"type",
"(",
")",
",",
"utils",
"get",
"call",
"location",
"name",
"(",
")",
",",
"true",
")",
";",
"/",
"/",
"create",
"transform",
"async",
"wait",
"operator",
"factory",
"<",
"in",
",",
"out",
">",
"factory",
"=",
"new",
"async",
"wait",
"operator",
"factory",
"<",
">",
"(",
"in",
"get",
"execution",
"environment",
"(",
")",
"clean",
"(",
"func",
")",
",",
"timeout",
",",
"buf",
"size",
",",
"mode",
")",
";",
"factory",
"set",
"chaining",
"strategy",
"(",
"chaining",
"strategy",
"always",
")",
";",
"return",
"in",
"transform",
"(",
"\"",
"async",
"wait",
"operator",
"\"",
",",
"out",
"type",
"info",
",",
"factory",
")",
";",
"}"
] |
[
"opens",
"a",
"file",
",",
"optional",
"if",
"it",
"should",
"append",
"to",
"the",
"recent",
"files",
"menu"
] | [
"public",
"static",
"void",
"open",
"files",
"(",
"final",
"file",
"[",
"]",
"files",
",",
"boolean",
"recent",
"files",
")",
"{",
"if",
"(",
"recent",
"files",
")",
"for",
"(",
"file",
"f",
":",
"files",
")",
"if",
"(",
"f",
"exists",
"(",
")",
")",
"bytecode",
"viewer",
"add",
"recent",
"file",
"(",
"f",
")",
";",
"bytecode",
"viewer",
"viewer",
"set",
"icon",
"(",
"true",
")",
";",
"update",
"=",
"true",
";",
"needs",
"re",
"dump",
"=",
"true",
";",
"thread",
"t",
"=",
"new",
"thread",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"run",
"(",
")",
"{",
"try",
"{",
"for",
"(",
"final",
"file",
"f",
":",
"files",
")",
"{",
"final",
"string",
"fn",
"=",
"f",
"get",
"name",
"(",
")",
";",
"if",
"(",
"!",
"f",
"exists",
"(",
")",
")",
"{",
"update",
"=",
"false",
";",
"show",
"message",
"(",
"\"",
"the",
"file",
"\"",
"+",
"f",
"get",
"absolute",
"path",
"(",
")",
"+",
"\"",
"could",
"not",
"be",
"found",
"\"",
")",
";",
"}",
"else",
"{",
"if",
"(",
"f",
"is",
"directory",
"(",
")",
")",
"{",
"file",
"container",
"container",
"=",
"new",
"file",
"container",
"(",
"f",
")",
";",
"hash",
"map",
"<",
"string",
",",
"byte",
"[",
"]",
">",
"files",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"boolean",
"finished",
"=",
"false",
";",
"array",
"list",
"<",
"file",
">",
"total",
"files",
"=",
"new",
"array",
"list",
"<",
"file",
">",
"(",
")",
";",
"total",
"files",
"add",
"(",
"f",
")",
";",
"string",
"dir",
"=",
"f",
"get",
"absolute",
"path",
"(",
")",
";",
"/",
"/",
"f",
"get",
"absolute",
"path",
"(",
")",
"substring",
"(",
"0",
",",
"f",
"get",
"absolute",
"path",
"(",
")",
"length",
"(",
")",
"-",
"f",
"get",
"name",
"(",
")",
"length",
"(",
")",
")",
";",
"while",
"(",
"!",
"finished",
")",
"{",
"boolean",
"added",
"=",
"false",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"total",
"files",
"size",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"file",
"child",
"=",
"total",
"files",
"get",
"(",
"i",
")",
";",
"if",
"(",
"child",
"list",
"files",
"(",
")",
"!",
"=",
"null",
")",
"for",
"(",
"file",
"rocket",
":",
"child",
"list",
"files",
"(",
")",
")",
"if",
"(",
"!",
"total",
"files",
"contains",
"(",
"rocket",
")",
")",
"{",
"total",
"files",
"add",
"(",
"rocket",
")",
";",
"added",
"=",
"true",
";",
"}",
"}",
"if",
"(",
"!",
"added",
")",
"{",
"for",
"(",
"file",
"child",
":",
"total",
"files",
")",
"if",
"(",
"child",
"is",
"file",
"(",
")",
")",
"{",
"string",
"file",
"name",
"=",
"child",
"get",
"absolute",
"path",
"(",
")",
"substring",
"(",
"dir",
"length",
"(",
")",
"+",
"1",
",",
"child",
"get",
"absolute",
"path",
"(",
")",
"length",
"(",
")",
")",
"replace",
"all",
"(",
"\"",
"\\",
"\\",
"\\",
"\\",
"\"",
",",
"\"",
"\\",
"\\",
"/",
"\"",
")",
";",
"files",
"put",
"(",
"file",
"name",
",",
"files",
"read",
"all",
"bytes",
"(",
"paths",
"get",
"(",
"child",
"get",
"absolute",
"path",
"(",
")",
")",
")",
")",
";",
"}",
"finished",
"=",
"true",
";",
"}",
"}",
"container",
"files",
"=",
"files",
";",
"bytecode",
"viewer",
"files",
"add",
"(",
"container",
")",
";",
"}",
"else",
"{",
"if",
"(",
"fn",
"ends",
"with",
"(",
"\"",
"jar",
"\"",
")",
"|",
"|",
"fn",
"ends",
"with",
"(",
"\"",
"zip",
"\"",
")",
"|",
"|",
"fn",
"ends",
"with",
"(",
"\"",
"war",
"\"",
")",
")",
"{",
"try",
"{",
"jar",
"utils",
"put",
"(",
"f",
")",
";",
"}",
"catch",
"(",
"java",
"io",
"i",
"o",
"exception",
"z",
")",
"{",
"try",
"{",
"jar",
"utils",
"put",
"2",
"(",
"f",
")",
";",
"}",
"catch",
"(",
"final",
"exception",
"e",
")",
"{",
"new",
"the",
"bytecode",
"club",
"bytecodeviewer",
"api",
"exception",
"u",
"i",
"(",
"e",
")",
";",
"update",
"=",
"false",
";",
"}",
"}",
"catch",
"(",
"final",
"exception",
"e",
")",
"{",
"new",
"the",
"bytecode",
"club",
"bytecodeviewer",
"api",
"exception",
"u",
"i",
"(",
"e",
")",
";",
"update",
"=",
"false",
";",
"}",
"}",
"else",
"if",
"(",
"fn",
"ends",
"with",
"(",
"\"",
"class",
"\"",
")",
")",
"{",
"try",
"{",
"byte",
"[",
"]",
"bytes",
"=",
"jar",
"utils",
"get",
"bytes",
"(",
"new",
"file",
"input",
"stream",
"(",
"f",
")",
")",
";",
"string",
"cafebabe",
"=",
"string",
"format",
"(",
"\"",
"%",
"02x",
"\"",
",",
"bytes",
"[",
"0",
"]",
")",
"+",
"string",
"format",
"(",
"\"",
"%",
"02x",
"\"",
",",
"bytes",
"[",
"1",
"]",
")",
"+",
"string",
"format",
"(",
"\"",
"%",
"02x",
"\"",
",",
"bytes",
"[",
"2",
"]",
")",
"+",
"string",
"format",
"(",
"\"",
"%",
"02x",
"\"",
",",
"bytes",
"[",
"3",
"]",
")",
";",
"if",
"(",
"cafebabe",
"to",
"lower",
"case",
"(",
")",
"equals",
"(",
"\"",
"cafebabe",
"\"",
")",
")",
"{",
"final",
"class",
"node",
"cn",
"=",
"jar",
"utils",
"get",
"node",
"(",
"bytes",
")",
";",
"file",
"container",
"container",
"=",
"new",
"file",
"container",
"(",
"f",
")",
";",
"container",
"classes",
"add",
"(",
"cn",
")",
";",
"bytecode",
"viewer",
"files",
"add",
"(",
"container",
")",
";",
"}",
"else",
"{",
"show",
"message",
"(",
"fn",
"+",
"\"",
":",
"header",
"does",
"not",
"start",
"with",
"cafebabe",
",",
"ignoring",
"\"",
")",
";",
"update",
"=",
"false",
";",
"}",
"}",
"catch",
"(",
"final",
"exception",
"e",
")",
"{",
"new",
"the",
"bytecode",
"club",
"bytecodeviewer",
"api",
"exception",
"u",
"i",
"(",
"e",
")",
";",
"update",
"=",
"false",
";",
"}",
"}",
"else",
"if",
"(",
"fn",
"ends",
"with",
"(",
"\"",
"apk",
"\"",
")",
")",
"{",
"try",
"{",
"bytecode",
"viewer",
"viewer",
"set",
"icon",
"(",
"true",
")",
";",
"file",
"temp",
"copy",
"=",
"new",
"file",
"(",
"temp",
"directory",
"+",
"fs",
"+",
"misc",
"utils",
"random",
"string",
"(",
"32",
")",
"+",
"\"",
"apk",
"\"",
")",
";",
"file",
"utils",
"copy",
"file",
"(",
"f",
",",
"temp",
"copy",
")",
";",
"file",
"container",
"container",
"=",
"new",
"file",
"container",
"(",
"temp",
"copy",
",",
"f",
"get",
"name",
"(",
")",
")",
";",
"if",
"(",
"viewer",
"decode",
"a",
"p",
"k",
"resources",
"is",
"selected",
"(",
")",
")",
"{",
"file",
"decoded",
"resources",
"=",
"new",
"file",
"(",
"temp",
"directory",
"+",
"fs",
"+",
"misc",
"utils",
"random",
"string",
"(",
"32",
")",
"+",
"\"",
"apk",
"\"",
")",
";",
"a",
"p",
"k",
"tool",
"decode",
"resources",
"(",
"temp",
"copy",
",",
"decoded",
"resources",
",",
"container",
")",
";",
"container",
"files",
"=",
"jar",
"utils",
"load",
"resources",
"(",
"decoded",
"resources",
")",
";",
"}",
"container",
"files",
"put",
"all",
"(",
"jar",
"utils",
"load",
"resources",
"(",
"temp",
"copy",
")",
")",
";",
"/",
"/",
"copy",
"and",
"rename",
"to",
"prevent",
"unicode",
"filenames",
"string",
"name",
"=",
"get",
"randomized",
"name",
"(",
")",
"+",
"\"",
"jar",
"\"",
";",
"file",
"output",
"=",
"new",
"file",
"(",
"temp",
"directory",
"+",
"fs",
"+",
"name",
")",
";",
"if",
"(",
"bytecode",
"viewer",
"viewer",
"apk",
"conversion",
"group",
"is",
"selected",
"(",
"bytecode",
"viewer",
"viewer",
"apk",
"conversion",
"dex",
"get",
"model",
"(",
")",
")",
")",
"dex",
"2",
"jar",
"dex",
"2",
"jar",
"(",
"temp",
"copy",
",",
"output",
")",
";",
"else",
"if",
"(",
"bytecode",
"viewer",
"viewer",
"apk",
"conversion",
"group",
"is",
"selected",
"(",
"bytecode",
"viewer",
"viewer",
"apk",
"conversion",
"enjarify",
"get",
"model",
"(",
")",
")",
")",
"enjarify",
"apk",
"2",
"jar",
"(",
"temp",
"copy",
",",
"output",
")",
";",
"container",
"classes",
"=",
"jar",
"utils",
"load",
"classes",
"(",
"output",
")",
";",
"bytecode",
"viewer",
"viewer",
"set",
"icon",
"(",
"false",
")",
";",
"bytecode",
"viewer",
"files",
"add",
"(",
"container",
")",
";",
"}",
"catch",
"(",
"final",
"exception",
"e",
")",
"{",
"new",
"the",
"bytecode",
"club",
"bytecodeviewer",
"api",
"exception",
"u",
"i",
"(",
"e",
")",
";",
"}",
"return",
";",
"}",
"else",
"if",
"(",
"fn",
"ends",
"with",
"(",
"\"",
"dex",
"\"",
")",
")",
"{",
"try",
"{",
"bytecode",
"viewer",
"viewer",
"set",
"icon",
"(",
"true",
")",
";",
"file",
"temp",
"copy",
"=",
"new",
"file",
"(",
"temp",
"directory",
"+",
"fs",
"+",
"misc",
"utils",
"random",
"string",
"(",
"32",
")",
"+",
"\"",
"dex",
"\"",
")",
";",
"file",
"utils",
"copy",
"file",
"(",
"f",
",",
"temp",
"copy",
")",
";",
"/",
"/",
"copy",
"and",
"rename",
"to",
"prevent",
"unicode",
"filenames",
"file",
"container",
"container",
"=",
"new",
"file",
"container",
"(",
"temp",
"copy",
",",
"f",
"get",
"name",
"(",
")",
")",
";",
"string",
"name",
"=",
"get",
"randomized",
"name",
"(",
")",
"+",
"\"",
"jar",
"\"",
";",
"file",
"output",
"=",
"new",
"file",
"(",
"temp",
"directory",
"+",
"fs",
"+",
"name",
")",
";",
"if",
"(",
"bytecode",
"viewer",
"viewer",
"apk",
"conversion",
"group",
"is",
"selected",
"(",
"bytecode",
"viewer",
"viewer",
"apk",
"conversion",
"dex",
"get",
"model",
"(",
")",
")",
")",
"dex",
"2",
"jar",
"dex",
"2",
"jar",
"(",
"temp",
"copy",
",",
"output",
")",
";",
"else",
"if",
"(",
"bytecode",
"viewer",
"viewer",
"apk",
"conversion",
"group",
"is",
"selected",
"(",
"bytecode",
"viewer",
"viewer",
"apk",
"conversion",
"enjarify",
"get",
"model",
"(",
")",
")",
")",
"enjarify",
"apk",
"2",
"jar",
"(",
"temp",
"copy",
",",
"output",
")",
";",
"container",
"classes",
"=",
"jar",
"utils",
"load",
"classes",
"(",
"output",
")",
";",
"bytecode",
"viewer",
"viewer",
"set",
"icon",
"(",
"false",
")",
";",
"bytecode",
"viewer",
"files",
"add",
"(",
"container",
")",
";",
"}",
"catch",
"(",
"final",
"exception",
"e",
")",
"{",
"new",
"the",
"bytecode",
"club",
"bytecodeviewer",
"api",
"exception",
"u",
"i",
"(",
"e",
")",
";",
"}",
"return",
";",
"}",
"else",
"{",
"hash",
"map",
"<",
"string",
",",
"byte",
"[",
"]",
">",
"files",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"byte",
"[",
"]",
"bytes",
"=",
"jar",
"utils",
"get",
"bytes",
"(",
"new",
"file",
"input",
"stream",
"(",
"f",
")",
")",
";",
"files",
"put",
"(",
"f",
"get",
"name",
"(",
")",
",",
"bytes",
")",
";",
"file",
"container",
"container",
"=",
"new",
"file",
"container",
"(",
"f",
")",
";",
"container",
"files",
"=",
"files",
";",
"bytecode",
"viewer",
"files",
"add",
"(",
"container",
")",
";",
"}",
"}",
"}",
"}",
"}",
"catch",
"(",
"final",
"exception",
"e",
")",
"{",
"new",
"the",
"bytecode",
"club",
"bytecodeviewer",
"api",
"exception",
"u",
"i",
"(",
"e",
")",
";",
"}",
"finally",
"{",
"bytecode",
"viewer",
"viewer",
"set",
"icon",
"(",
"false",
")",
";",
"if",
"(",
"update",
")",
"try",
"{",
"main",
"viewer",
"g",
"u",
"i",
"get",
"component",
"(",
"file",
"navigation",
"pane",
"class",
")",
"update",
"tree",
"(",
")",
";",
"}",
"catch",
"(",
"java",
"lang",
"null",
"pointer",
"exception",
"e",
")",
"{",
"}",
"}",
"}",
"}",
";",
"t",
"start",
"(",
")",
";",
"}"
] |
[
"returns",
"data",
"for",
"a",
"json",
"map",
"containing",
"the",
"information",
"for",
"the",
"set",
"of",
"files",
"in",
"'",
"path",
"'",
"that",
"match",
"'",
"filter",
"'"
] | [
"public",
"map",
"execute",
"(",
"file",
"system",
"fs",
")",
"throws",
"i",
"o",
"exception",
"{",
"file",
"status",
"[",
"]",
"file",
"statuses",
"=",
"fs",
"list",
"status",
"(",
"path",
",",
"filter",
")",
";",
"http",
"f",
"s",
"server",
"web",
"app",
"get",
"(",
")",
"get",
"metrics",
"(",
")",
"incr",
"ops",
"listing",
"(",
")",
";",
"return",
"to",
"json",
"(",
"file",
"statuses",
",",
"fs",
"get",
"file",
"status",
"(",
"path",
")",
"is",
"file",
"(",
")",
")",
";",
"}"
] |
[
"removes",
"a",
"listener",
"for",
"updated",
"cluster",
"states"
] | [
"public",
"void",
"remove",
"listener",
"(",
"cluster",
"state",
"listener",
"listener",
")",
"{",
"cluster",
"state",
"listeners",
"remove",
"(",
"listener",
")",
";",
"}"
] |
[
"zookeeper",
"-",
"1573",
":",
"test",
"restoring",
"a",
"snapshot",
"with",
"deleted",
"txns",
"ahead",
"of",
"the",
"snapshot",
"file",
"'",
"s",
"zxid"
] | [
"public",
"void",
"test",
"reload",
"snapshot",
"with",
"missing",
"parent",
"(",
")",
"throws",
"exception",
"{",
"/",
"/",
"create",
"transactions",
"to",
"create",
"the",
"snapshot",
"with",
"create",
"/",
"delete",
"pattern",
"zoo",
"keeper",
"zk",
"=",
"create",
"z",
"k",
"client",
"(",
"host",
"port",
")",
";",
"zk",
"create",
"(",
"\"",
"/",
"a",
"\"",
",",
"\"",
"\"",
"get",
"bytes",
"(",
")",
",",
"ids",
"open",
"acl",
"unsafe",
",",
"create",
"mode",
"persistent",
")",
";",
"stat",
"stat",
"=",
"zk",
"exists",
"(",
"\"",
"/",
"a",
"\"",
",",
"false",
")",
";",
"long",
"create",
"zx",
"id",
"=",
"stat",
"get",
"mzxid",
"(",
")",
";",
"zk",
"create",
"(",
"\"",
"/",
"a",
"/",
"b",
"\"",
",",
"\"",
"\"",
"get",
"bytes",
"(",
")",
",",
"ids",
"open",
"acl",
"unsafe",
",",
"create",
"mode",
"persistent",
")",
";",
"zk",
"delete",
"(",
"\"",
"/",
"a",
"/",
"b",
"\"",
",",
"-",
"1",
")",
";",
"zk",
"delete",
"(",
"\"",
"/",
"a",
"\"",
",",
"-",
"1",
")",
";",
"/",
"/",
"force",
"the",
"zxid",
"to",
"be",
"behind",
"the",
"content",
"zoo",
"keeper",
"server",
"zks",
"=",
"server",
"factory",
"get",
"zoo",
"keeper",
"server",
"(",
")",
";",
"zks",
"get",
"z",
"k",
"database",
"(",
")",
"setlast",
"processed",
"zxid",
"(",
"create",
"zx",
"id",
")",
";",
"log",
"info",
"(",
"\"",
"set",
"last",
"processed",
"zxid",
"to",
"{",
"}",
"\"",
",",
"zks",
"get",
"z",
"k",
"database",
"(",
")",
"get",
"data",
"tree",
"last",
"processed",
"zxid",
"(",
")",
")",
";",
"/",
"/",
"force",
"snapshot",
"and",
"restore",
"zks",
"take",
"snapshot",
"(",
")",
";",
"zks",
"shutdown",
"(",
")",
";",
"stop",
"server",
"(",
")",
";",
"start",
"server",
"(",
")",
";",
"}"
] |
[
"optional",
",",
"the",
"largest",
"value",
"of",
"the",
"last",
"partition"
] | [
"public",
"builder",
"set",
"partition",
"upper",
"bound",
"(",
"long",
"partition",
"upper",
"bound",
")",
"{",
"this",
"partition",
"upper",
"bound",
"=",
"partition",
"upper",
"bound",
";",
"return",
"this",
";",
"}"
] |
[
"return",
"the",
"drawable",
"in",
"cache"
] | [
"public",
"static",
"drawable",
"get",
"drawable",
"(",
"@",
"non",
"null",
"final",
"string",
"key",
",",
"@",
"non",
"null",
"final",
"cache",
"double",
"utils",
"cache",
"double",
"utils",
")",
"{",
"return",
"cache",
"double",
"utils",
"get",
"drawable",
"(",
"key",
")",
";",
"}"
] |
[
"returns",
"the",
"maximum",
"frame",
"set",
"by",
"{",
"@",
"link",
"#",
"set",
"max",
"frame",
"(",
"int",
")",
"}",
"or",
"{",
"@",
"link",
"#",
"set",
"max",
"progress",
"(",
"float",
")",
"}"
] | [
"public",
"float",
"get",
"max",
"frame",
"(",
")",
"{",
"return",
"lottie",
"drawable",
"get",
"max",
"frame",
"(",
")",
";",
"}"
] |
[
"if",
"dead",
"node",
"detection",
"enabled",
"is",
"true",
",",
"judgement",
"based",
"on",
"whether",
"this",
"datanode",
"is",
"included",
"or",
"not",
"in",
"dead",
"node",
"detector",
"otherwise",
"judgment",
"based",
"given",
"d",
"f",
"s",
"input",
"stream"
] | [
"public",
"boolean",
"is",
"dead",
"node",
"(",
"d",
"f",
"s",
"input",
"stream",
"dfs",
"input",
"stream",
",",
"datanode",
"info",
"datanode",
"info",
")",
"{",
"if",
"(",
"is",
"dead",
"node",
"detection",
"enabled",
"(",
")",
")",
"{",
"boolean",
"is",
"dead",
"node",
"=",
"client",
"context",
"get",
"dead",
"node",
"detector",
"(",
")",
"is",
"dead",
"node",
"(",
"datanode",
"info",
")",
";",
"if",
"(",
"dfs",
"input",
"stream",
"!",
"=",
"null",
")",
"{",
"is",
"dead",
"node",
"=",
"is",
"dead",
"node",
"|",
"|",
"dfs",
"input",
"stream",
"get",
"local",
"dead",
"nodes",
"(",
")",
"contains",
"(",
"datanode",
"info",
")",
";",
"}",
"return",
"is",
"dead",
"node",
";",
"}",
"else",
"{",
"return",
"dfs",
"input",
"stream",
"get",
"local",
"dead",
"nodes",
"(",
")",
"contains",
"(",
"datanode",
"info",
")",
";",
"}",
"}"
] |
[
"get",
"the",
"unique",
"start",
"time",
"for",
"a",
"given",
"entity",
"as",
"a",
"byte",
"array",
"that",
"sorts",
"the",
"timestamps",
"in",
"reverse",
"order",
"(",
"see",
"{",
"@",
"link",
"generic",
"object",
"mapper",
"#",
"write",
"reverse",
"ordered",
"long",
"(",
"long",
")",
"}",
")"
] | [
"private",
"byte",
"[",
"]",
"get",
"start",
"time",
"(",
"string",
"entity",
"id",
",",
"string",
"entity",
"type",
")",
"throws",
"i",
"o",
"exception",
"{",
"long",
"l",
"=",
"get",
"start",
"time",
"long",
"(",
"entity",
"id",
",",
"entity",
"type",
")",
";",
"return",
"l",
"=",
"=",
"null",
"?",
"null",
":",
"write",
"reverse",
"ordered",
"long",
"(",
"l",
")",
";",
"}"
] |
[
"overwrite",
"the",
"package",
"attribute",
"of",
"{",
"@",
"code",
"<",
"manifest",
">",
"}",
"in",
"an",
"android",
"manifest",
"xml",
"file"
] | [
"public",
"path",
"write",
"manifest",
"package",
"(",
"path",
"manifest",
",",
"string",
"custom",
"package",
",",
"path",
"output",
")",
"{",
"if",
"(",
"strings",
"is",
"null",
"or",
"empty",
"(",
"custom",
"package",
")",
")",
"{",
"return",
"manifest",
";",
"}",
"try",
"{",
"files",
"create",
"directories",
"(",
"output",
"get",
"parent",
"(",
")",
")",
";",
"x",
"m",
"l",
"event",
"reader",
"reader",
"=",
"x",
"m",
"l",
"input",
"factory",
"new",
"instance",
"(",
")",
"create",
"x",
"m",
"l",
"event",
"reader",
"(",
"files",
"new",
"input",
"stream",
"(",
"manifest",
")",
",",
"utf",
"8",
"name",
"(",
")",
")",
";",
"x",
"m",
"l",
"event",
"writer",
"writer",
"=",
"x",
"m",
"l",
"output",
"factory",
"new",
"instance",
"(",
")",
"create",
"x",
"m",
"l",
"event",
"writer",
"(",
"files",
"new",
"output",
"stream",
"(",
"output",
")",
",",
"utf",
"8",
"name",
"(",
")",
")",
";",
"x",
"m",
"l",
"event",
"factory",
"event",
"factory",
"=",
"x",
"m",
"l",
"event",
"factory",
"new",
"instance",
"(",
")",
";",
"while",
"(",
"reader",
"has",
"next",
"(",
")",
")",
"{",
"x",
"m",
"l",
"event",
"event",
"=",
"reader",
"next",
"event",
"(",
")",
";",
"if",
"(",
"event",
"is",
"start",
"element",
"(",
")",
"&",
"&",
"event",
"as",
"start",
"element",
"(",
")",
"get",
"name",
"(",
")",
"to",
"string",
"(",
")",
"equals",
"ignore",
"case",
"(",
"\"",
"manifest",
"\"",
")",
")",
"{",
"start",
"element",
"element",
"=",
"event",
"as",
"start",
"element",
"(",
")",
";",
"@",
"suppress",
"warnings",
"(",
"\"",
"unchecked",
"\"",
")",
"iterator",
"<",
"attribute",
">",
"attributes",
"=",
"element",
"get",
"attributes",
"(",
")",
";",
"immutable",
"list",
"builder",
"<",
"attribute",
">",
"new",
"attributes",
"=",
"immutable",
"list",
"builder",
"(",
")",
";",
"while",
"(",
"attributes",
"has",
"next",
"(",
")",
")",
"{",
"attribute",
"attr",
"=",
"attributes",
"next",
"(",
")",
";",
"if",
"(",
"attr",
"get",
"name",
"(",
")",
"to",
"string",
"(",
")",
"equals",
"ignore",
"case",
"(",
"\"",
"package",
"\"",
")",
")",
"{",
"new",
"attributes",
"add",
"(",
"event",
"factory",
"create",
"attribute",
"(",
"\"",
"package",
"\"",
",",
"custom",
"package",
")",
")",
";",
"}",
"else",
"{",
"new",
"attributes",
"add",
"(",
"attr",
")",
";",
"}",
"}",
"writer",
"add",
"(",
"event",
"factory",
"create",
"start",
"element",
"(",
"element",
"get",
"name",
"(",
")",
",",
"new",
"attributes",
"build",
"(",
")",
"iterator",
"(",
")",
",",
"element",
"get",
"namespaces",
"(",
")",
")",
")",
";",
"}",
"else",
"{",
"writer",
"add",
"(",
"event",
")",
";",
"}",
"}",
"writer",
"flush",
"(",
")",
";",
"}",
"catch",
"(",
"x",
"m",
"l",
"stream",
"exception",
"|",
"factory",
"configuration",
"error",
"|",
"i",
"o",
"exception",
"e",
")",
"{",
"throw",
"new",
"manifest",
"processing",
"exception",
"(",
"e",
")",
";",
"}",
"return",
"output",
";",
"}"
] |
[
"intern",
"the",
"given",
"triple",
"as",
"an",
"instance",
"of",
"this",
"class"
] | [
"private",
"static",
"register",
"spec",
"intern",
"(",
"int",
"reg",
",",
"type",
"bearer",
"type",
",",
"local",
"item",
"local",
")",
"{",
"synchronized",
"(",
"the",
"interns",
")",
"{",
"the",
"interning",
"item",
"set",
"(",
"reg",
",",
"type",
",",
"local",
")",
";",
"register",
"spec",
"found",
"=",
"the",
"interns",
"get",
"(",
"the",
"interning",
"item",
")",
";",
"if",
"(",
"found",
"!",
"=",
"null",
")",
"{",
"return",
"found",
";",
"}",
"found",
"=",
"the",
"interning",
"item",
"to",
"register",
"spec",
"(",
")",
";",
"the",
"interns",
"put",
"(",
"found",
",",
"found",
")",
";",
"return",
"found",
";",
"}",
"}"
] |
[
"returns",
"the",
"block",
"to",
"be",
"added"
] | [
"public",
"a",
"p",
"i",
"block",
"get",
"block",
"(",
")",
"{",
"return",
"block",
";",
"}"
] |
[
"updates",
"a",
"pet",
"in",
"the",
"store",
"with",
"form",
"data"
] | [
"public",
"void",
"update",
"pet",
"with",
"form",
"(",
"@",
"path",
"param",
"(",
"\"",
"pet",
"id",
"\"",
")",
"long",
"pet",
"id",
",",
"@",
"multipart",
"(",
"value",
"=",
"\"",
"name",
"\"",
",",
"required",
"=",
"false",
")",
"string",
"name",
",",
"@",
"multipart",
"(",
"value",
"=",
"\"",
"status",
"\"",
",",
"required",
"=",
"false",
")",
"string",
"status",
")",
";"
] |
[
"this",
"is",
"only",
"of",
"interest",
"for",
"spring",
"aop",
":",
"aspect",
"j",
"instantiation",
"semantics",
"are",
"much",
"richer",
"in",
"aspect",
"j",
"terminology",
",",
"all",
"a",
"return",
"of",
"{",
"@",
"code",
"true",
"}",
"means",
"here",
"is",
"that",
"the",
"aspect",
"is",
"not",
"a",
"singleton"
] | [
"public",
"boolean",
"is",
"per",
"instance",
"(",
")",
"{",
"return",
"(",
"get",
"aspect",
"metadata",
"(",
")",
"get",
"aj",
"type",
"(",
")",
"get",
"per",
"clause",
"(",
")",
"get",
"kind",
"(",
")",
"!",
"=",
"per",
"clause",
"kind",
"singleton",
")",
";",
"}"
] |
[
"set",
"the",
"current",
"locale",
"to",
"the",
"given",
"one"
] | [
"void",
"set",
"locale",
"(",
"http",
"servlet",
"request",
"request",
",",
"@",
"nullable",
"http",
"servlet",
"response",
"response",
",",
"@",
"nullable",
"locale",
"locale",
")",
";"
] |
[
"get",
"the",
"association",
"type"
] | [
"public",
"int",
"get",
"association",
"type",
"(",
")",
"{",
"return",
"association",
"type",
";",
"}"
] |
[
"a",
"single",
"non",
"-",
"error",
"failure",
"is",
"not",
"logged",
"because",
"it",
"is",
"reported",
"via",
"the",
"output",
"future"
] | [
"public",
"void",
"test",
"all",
"as",
"list",
"logging",
"exception",
"(",
")",
"throws",
"exception",
"{",
"try",
"{",
"get",
"done",
"(",
"all",
"as",
"list",
"(",
"immediate",
"failed",
"future",
"(",
"new",
"my",
"exception",
"(",
")",
")",
")",
")",
";",
"fail",
"(",
")",
";",
"}",
"catch",
"(",
"execution",
"exception",
"expected",
")",
"{",
"assert",
"that",
"(",
"expected",
"get",
"cause",
"(",
")",
")",
"is",
"instance",
"of",
"(",
"my",
"exception",
"class",
")",
";",
"assert",
"equals",
"(",
"\"",
"nothing",
"should",
"be",
"logged",
"\"",
",",
"0",
",",
"aggregate",
"future",
"log",
"handler",
"get",
"stored",
"log",
"records",
"(",
")",
"size",
"(",
")",
")",
";",
"}",
"}"
] |
[
"returns",
"the",
"value",
"of",
"the",
"requested",
"attribute",
",",
"or",
"-",
"default",
"value",
"-",
"if",
"the",
"attribute",
"is",
"missing"
] | [
"public",
"long",
"get",
"long",
"(",
"int",
"attribute",
",",
"long",
"default",
"value",
")",
"{",
"d",
"w",
"a",
"r",
"f",
"numeric",
"attribute",
"attr",
"=",
"get",
"attribute",
"(",
"attribute",
",",
"d",
"w",
"a",
"r",
"f",
"numeric",
"attribute",
"class",
")",
";",
"return",
"(",
"attr",
"!",
"=",
"null",
")",
"?",
"attr",
"get",
"value",
"(",
")",
":",
"default",
"value",
";",
"}"
] |
[
"called",
"each",
"time",
"offline",
"drm",
"keys",
"are",
"removed"
] | [
"default",
"void",
"on",
"drm",
"keys",
"removed",
"(",
"event",
"time",
"event",
"time",
")",
"{",
"}"
] |
[
"gets",
"the",
"command",
"name",
"for",
"example",
",",
"if",
"the",
"cli",
"is",
"invoked",
"as",
"{",
"@",
"code",
"java",
"-",
"jar",
"cli",
"jar",
"foo",
"arg",
"1",
"arg",
"2",
"arg",
"4",
"}",
",",
"on",
"the",
"server",
"side",
"{",
"@",
"link",
"c",
"l",
"i",
"command",
"}",
"that",
"returns",
"\"",
"foo",
"\"",
"from",
"{",
"@",
"link",
"#",
"get",
"name",
"(",
")",
"}",
"will",
"be",
"invoked",
"by",
"default",
",",
"this",
"method",
"creates",
"\"",
"foo",
"-",
"bar",
"-",
"zot",
"\"",
"from",
"\"",
"foo",
"bar",
"zot",
"command",
"\""
] | [
"public",
"string",
"get",
"name",
"(",
")",
"{",
"string",
"name",
"=",
"get",
"class",
"(",
")",
"get",
"name",
"(",
")",
";",
"name",
"=",
"name",
"substring",
"(",
"name",
"last",
"index",
"of",
"(",
"'",
"'",
")",
"+",
"1",
")",
";",
"/",
"/",
"short",
"name",
"name",
"=",
"name",
"substring",
"(",
"name",
"last",
"index",
"of",
"(",
"'",
"$",
"'",
")",
"+",
"1",
")",
";",
"if",
"(",
"name",
"ends",
"with",
"(",
"\"",
"command",
"\"",
")",
")",
"name",
"=",
"name",
"substring",
"(",
"0",
",",
"name",
"length",
"(",
")",
"-",
"7",
")",
";",
"/",
"/",
"trim",
"off",
"the",
"command",
"/",
"/",
"convert",
"\"",
"foo",
"bar",
"zot",
"\"",
"into",
"\"",
"foo",
"-",
"bar",
"-",
"zot",
"\"",
"/",
"/",
"locale",
"is",
"fixed",
"so",
"that",
"\"",
"create",
"instance",
"\"",
"always",
"become",
"\"",
"create",
"-",
"instance",
"\"",
"no",
"matter",
"where",
"this",
"is",
"run",
"return",
"name",
"replace",
"all",
"(",
"\"",
"(",
"[",
"a",
"-",
"z",
"0",
"-",
"9",
"]",
")",
"(",
"[",
"a",
"-",
"z",
"]",
")",
"\"",
",",
"\"",
"$",
"1",
"-",
"$",
"2",
"\"",
")",
"to",
"lower",
"case",
"(",
"locale",
"english",
")",
";",
"}"
] |
[
"get",
"small",
"snake"
] | [
"public",
"string",
"get",
"small",
"snake",
"(",
")",
"{",
"return",
"small",
"snake",
";",
"}"
] |
[
"tool",
"was",
"added",
"to",
"the",
"given",
"workspace"
] | [
"public",
"void",
"tool",
"added",
"(",
"workspace",
"ws",
",",
"plugin",
"tool",
"tool",
")",
"{",
"add",
"tool",
"(",
"ws",
"get",
"name",
"(",
")",
",",
"tool",
")",
";",
"plugin",
"get",
"tool",
"action",
"manager",
"(",
")",
"enable",
"connect",
"tools",
"(",
")",
";",
"}"
] |
[
"adds",
"to",
"the",
"set",
"of",
"warnings",
"that",
"are",
"permissible",
"(",
"but",
"not",
"required",
")",
"when",
"running",
"in",
"mixed",
"-",
"version",
"clusters",
"or",
"those",
"that",
"differ",
"in",
"version",
"from",
"the",
"test",
"client"
] | [
"public",
"void",
"compatible",
"(",
"string",
"allowed",
"warnings",
")",
"{",
"this",
"allowed",
"warnings",
"add",
"all",
"(",
"arrays",
"as",
"list",
"(",
"allowed",
"warnings",
")",
")",
";",
"}"
] |
[
"tries",
"to",
"find",
"the",
"user",
"library",
"directory"
] | [
"public",
"static",
"optional",
"<",
"file",
">",
"try",
"find",
"user",
"lib",
"directory",
"(",
")",
"{",
"final",
"file",
"flink",
"home",
"directory",
"=",
"derive",
"flink",
"home",
"directory",
"from",
"lib",
"directory",
"(",
")",
";",
"final",
"file",
"usr",
"lib",
"directory",
"=",
"new",
"file",
"(",
"flink",
"home",
"directory",
",",
"config",
"constants",
"default",
"flink",
"usr",
"lib",
"dir",
")",
";",
"if",
"(",
"!",
"usr",
"lib",
"directory",
"is",
"directory",
"(",
")",
")",
"{",
"return",
"optional",
"empty",
"(",
")",
";",
"}",
"return",
"optional",
"of",
"(",
"usr",
"lib",
"directory",
")",
";",
"}"
] |
[
"set",
"the",
"servlet",
"context",
"that",
"this",
"web",
"application",
"context",
"runs",
"in"
] | [
"public",
"void",
"set",
"servlet",
"context",
"(",
"@",
"nullable",
"servlet",
"context",
"servlet",
"context",
")",
"{",
"this",
"servlet",
"context",
"=",
"servlet",
"context",
";",
"}"
] |
[
"set",
"an",
"alternative",
"logger",
"to",
"use",
"than",
"the",
"one",
"based",
"on",
"the",
"class",
"name"
] | [
"public",
"void",
"set",
"logger",
"(",
"log",
"logger",
")",
"{",
"this",
"logger",
"=",
"logger",
";",
"}"
] |
[
"return",
"the",
"instantiation",
"type",
"of",
"the",
"property",
",",
"especially",
"for",
"map",
"and",
"array"
] | [
"public",
"string",
"to",
"instantiation",
"type",
"(",
"schema",
"schema",
")",
"{",
"if",
"(",
"model",
"utils",
"is",
"map",
"schema",
"(",
"schema",
")",
")",
"{",
"schema",
"additional",
"properties",
"=",
"get",
"additional",
"properties",
"(",
"schema",
")",
";",
"string",
"inner",
"=",
"get",
"schema",
"type",
"(",
"additional",
"properties",
")",
";",
"if",
"(",
"model",
"utils",
"is",
"map",
"schema",
"(",
"additional",
"properties",
")",
")",
"{",
"inner",
"=",
"to",
"instantiation",
"type",
"(",
"additional",
"properties",
")",
";",
"}",
"return",
"instantiation",
"types",
"get",
"(",
"\"",
"map",
"\"",
")",
"+",
"\"",
"<",
"string",
",",
"\"",
"+",
"inner",
"+",
"\"",
">",
"\"",
";",
"}",
"else",
"if",
"(",
"model",
"utils",
"is",
"array",
"schema",
"(",
"schema",
")",
")",
"{",
"array",
"schema",
"array",
"schema",
"=",
"(",
"array",
"schema",
")",
"schema",
";",
"string",
"inner",
"=",
"get",
"schema",
"type",
"(",
"array",
"schema",
"get",
"items",
"(",
")",
")",
";",
"return",
"instantiation",
"types",
"get",
"(",
"\"",
"array",
"\"",
")",
"+",
"\"",
"<",
"\"",
"+",
"inner",
"+",
"\"",
">",
"\"",
";",
"}",
"else",
"{",
"return",
"null",
";",
"}",
"}"
] |
[
"analyzes",
"text",
"using",
"a",
"custom",
"analyzer",
"built",
"from",
"components",
"defined",
"on",
"an",
"index"
] | [
"public",
"static",
"custom",
"analyzer",
"builder",
"build",
"custom",
"analyzer",
"(",
"string",
"index",
",",
"map",
"<",
"string",
",",
"object",
">",
"tokenizer",
"settings",
")",
"{",
"return",
"new",
"custom",
"analyzer",
"builder",
"(",
"index",
",",
"new",
"name",
"or",
"definition",
"(",
"tokenizer",
"settings",
")",
")",
";",
"}"
] |
[
"returns",
"an",
"iterator",
"on",
"a",
"copy",
"of",
"the",
"internal",
"array",
"so",
"that",
"the",
"iterator",
"won",
"'",
"t",
"fail",
"by",
"buckets",
"being",
"addedremoved",
"concurrently"
] | [
"public",
"iterator",
"<",
"bucket",
">",
"iterator",
"(",
")",
"{",
"return",
"collections",
"unmodifiable",
"list",
"(",
"arrays",
"as",
"list",
"(",
"get",
"array",
"(",
")",
")",
")",
"iterator",
"(",
")",
";",
"}"
] |
[
"processes",
"element",
"to",
"deduplicate",
"on",
"keys",
"with",
"process",
"time",
"semantic",
",",
"sends",
"current",
"element",
"as",
"last",
"row",
",",
"retracts",
"previous",
"element",
"if",
"needed"
] | [
"static",
"void",
"process",
"last",
"row",
"on",
"proc",
"time",
"(",
"row",
"data",
"current",
"row",
",",
"boolean",
"generate",
"update",
"before",
",",
"boolean",
"generate",
"insert",
",",
"value",
"state",
"<",
"row",
"data",
">",
"state",
",",
"collector",
"<",
"row",
"data",
">",
"out",
")",
"throws",
"exception",
"{",
"check",
"insert",
"only",
"(",
"current",
"row",
")",
";",
"if",
"(",
"generate",
"update",
"before",
"|",
"|",
"generate",
"insert",
")",
"{",
"/",
"/",
"use",
"state",
"to",
"keep",
"the",
"previous",
"row",
"content",
"if",
"we",
"need",
"to",
"generate",
"update",
"before",
"/",
"/",
"or",
"use",
"to",
"distinguish",
"the",
"first",
"row",
",",
"if",
"we",
"need",
"to",
"generate",
"insert",
"row",
"data",
"pre",
"row",
"=",
"state",
"value",
"(",
")",
";",
"state",
"update",
"(",
"current",
"row",
")",
";",
"if",
"(",
"pre",
"row",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"the",
"first",
"row",
",",
"send",
"insert",
"message",
"current",
"row",
"set",
"row",
"kind",
"(",
"row",
"kind",
"insert",
")",
";",
"out",
"collect",
"(",
"current",
"row",
")",
";",
"}",
"else",
"{",
"if",
"(",
"generate",
"update",
"before",
")",
"{",
"pre",
"row",
"set",
"row",
"kind",
"(",
"row",
"kind",
"update",
"before",
")",
";",
"out",
"collect",
"(",
"pre",
"row",
")",
";",
"}",
"current",
"row",
"set",
"row",
"kind",
"(",
"row",
"kind",
"update",
"after",
")",
";",
"out",
"collect",
"(",
"current",
"row",
")",
";",
"}",
"}",
"else",
"{",
"/",
"/",
"always",
"send",
"update",
"after",
"if",
"insert",
"is",
"not",
"needed",
"current",
"row",
"set",
"row",
"kind",
"(",
"row",
"kind",
"update",
"after",
")",
";",
"out",
"collect",
"(",
"current",
"row",
")",
";",
"}",
"}"
] |
[
"populates",
"the",
"configuration",
"specific",
"mnemonic",
"to",
"extra",
"action",
"map",
"based",
"on",
"all",
"action",
"listers",
"selected",
"by",
"the",
"user",
"(",
"via",
"the",
"blaze",
"option",
"{",
"@",
"code",
"-",
"-",
"experimental",
"action",
"listener",
"=",
"<",
"target",
">",
"}",
")"
] | [
"private",
"static",
"multimap",
"<",
"string",
",",
"extra",
"action",
"spec",
">",
"compute",
"mnemonics",
"to",
"extra",
"action",
"map",
"(",
"rule",
"context",
"rule",
"context",
")",
"{",
"/",
"/",
"we",
"copy",
"the",
"multimap",
"here",
"every",
"time",
"this",
"could",
"be",
"expensive",
"multimap",
"<",
"string",
",",
"extra",
"action",
"spec",
">",
"mnemonic",
"to",
"extra",
"action",
"map",
"=",
"hash",
"multimap",
"create",
"(",
")",
";",
"for",
"(",
"transitive",
"info",
"collection",
"action",
"listener",
":",
"rule",
"context",
"get",
"prerequisites",
"(",
"\"",
":",
"action",
"listener",
"\"",
")",
")",
"{",
"extra",
"action",
"map",
"provider",
"provider",
"=",
"action",
"listener",
"get",
"provider",
"(",
"extra",
"action",
"map",
"provider",
"class",
")",
";",
"if",
"(",
"provider",
"=",
"=",
"null",
")",
"{",
"rule",
"context",
"rule",
"error",
"(",
"string",
"format",
"(",
"\"",
"unable",
"to",
"match",
"experimental",
"action",
"listeners",
"to",
"this",
"rule",
"\"",
"+",
"\"",
"specified",
"target",
"%",
"s",
"is",
"not",
"an",
"action",
"listener",
"rule",
"\"",
",",
"action",
"listener",
"get",
"label",
"(",
")",
"to",
"string",
"(",
")",
")",
")",
";",
"}",
"else",
"{",
"mnemonic",
"to",
"extra",
"action",
"map",
"put",
"all",
"(",
"provider",
"get",
"extra",
"action",
"map",
"(",
")",
")",
";",
"}",
"}",
"return",
"mnemonic",
"to",
"extra",
"action",
"map",
";",
"}"
] |
[
"setter",
"is",
"to",
"give",
"subclasses",
"the",
"ability",
"to",
"manipulate",
"the",
"service"
] | [
"protected",
"void",
"set",
"service",
"(",
"s",
"s",
")",
"{",
"this",
"service",
"=",
"s",
";",
"}"
] |
[
"removes",
"a",
"{",
"@",
"link",
"metadata",
"output",
"}"
] | [
"void",
"remove",
"metadata",
"output",
"(",
"metadata",
"output",
"output",
")",
";"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.