docstring_tokens
list | code_tokens
list |
|---|---|
[
"test",
"{",
"@",
"link",
"url",
"#",
"get",
"parameters",
"(",
"predicate",
")",
"}",
"method"
]
| [
"public",
"void",
"test",
"get",
"parameters",
"(",
")",
"{",
"url",
"url",
"=",
"url",
"value",
"of",
"(",
"\"",
"10",
"20",
"130",
"230",
":",
"20880",
"/",
"context",
"/",
"path",
"?",
"interface",
"=",
"org",
"apache",
"dubbo",
"test",
"interface",
"name",
"&",
"group",
"=",
"group",
"&",
"version",
"=",
"1",
"0",
"0",
"\"",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"parameters",
"=",
"url",
"get",
"parameters",
"(",
"i",
"-",
">",
"\"",
"version",
"\"",
"equals",
"(",
"i",
")",
")",
";",
"string",
"version",
"=",
"parameters",
"get",
"(",
"\"",
"version",
"\"",
")",
";",
"assert",
"equals",
"(",
"1",
",",
"parameters",
"size",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"1",
"0",
"0",
"\"",
",",
"version",
")",
";",
"}"
]
|
[
"get",
"information",
"about",
"the",
"nodes",
"in",
"the",
"cluster",
",",
"using",
"the",
"default",
"options",
"this",
"is",
"a",
"convenience",
"method",
"for",
"{",
"@",
"link",
"#",
"describe",
"cluster",
"(",
"describe",
"cluster",
"options",
")",
"}",
"with",
"default",
"options",
"see",
"the",
"overload",
"for",
"more",
"details"
]
| [
"default",
"describe",
"cluster",
"result",
"describe",
"cluster",
"(",
")",
"{",
"return",
"describe",
"cluster",
"(",
"new",
"describe",
"cluster",
"options",
"(",
")",
")",
";",
"}"
]
|
[
"tests",
"purge",
"where",
"the",
"data",
"directory",
"contains",
"snap",
"files",
"equals",
"to",
"the",
"number",
"of",
"files",
"to",
"be",
"retained",
",",
"and",
"a",
"log",
"file",
"that",
"precedes",
"the",
"earliest",
"snapshot"
]
| [
"public",
"void",
"test",
"snap",
"files",
"equals",
"to",
"retain",
"with",
"preceding",
"log",
"(",
")",
"throws",
"exception",
"{",
"internal",
"test",
"snap",
"files",
"equals",
"to",
"retain",
"(",
"true",
")",
";",
"}"
]
|
[
"adds",
"validation",
"to",
"a",
"parameter",
",",
"called",
"after",
"parsing",
"and",
"merging"
]
| [
"public",
"parameter",
"<",
"t",
">",
"set",
"validator",
"(",
"consumer",
"<",
"t",
">",
"validator",
")",
"{",
"this",
"validator",
"=",
"validator",
";",
"return",
"this",
";",
"}"
]
|
[
"set",
"total",
"number",
"of",
"blocks"
]
| [
"void",
"set",
"block",
"total",
"(",
"long",
"total",
")",
"{",
"assert",
"namesystem",
"has",
"write",
"lock",
"(",
")",
";",
"synchronized",
"(",
"this",
")",
"{",
"this",
"block",
"total",
"=",
"total",
";",
"this",
"block",
"threshold",
"=",
"(",
"long",
")",
"(",
"total",
"*",
"threshold",
")",
";",
"}",
"this",
"block",
"repl",
"queue",
"threshold",
"=",
"(",
"long",
")",
"(",
"total",
"*",
"repl",
"queue",
"threshold",
")",
";",
"}"
]
|
[
"returns",
"an",
"array",
"of",
"data",
"type",
"components",
"that",
"make",
"up",
"this",
"composite",
"including",
"undefined",
"filler",
"components",
"which",
"may",
"be",
"present",
"within",
"an",
"unaligned",
"structure",
"the",
"number",
"of",
"components",
"corresponds",
"to",
"{",
"@",
"link",
"#",
"get",
"num",
"components",
"(",
")",
"}"
]
| [
"public",
"abstract",
"data",
"type",
"component",
"[",
"]",
"get",
"components",
"(",
")",
";"
]
|
[
"augment",
"mfa",
"provider",
"flow",
"registry"
]
| [
"private",
"void",
"augment",
"multifactor",
"provider",
"flow",
"registry",
"(",
")",
"{",
"multifactor",
"authentication",
"flow",
"definition",
"registries",
"for",
"each",
"(",
"registry",
"-",
">",
"{",
"val",
"flow",
"ids",
"=",
"registry",
"get",
"flow",
"definition",
"ids",
"(",
")",
";",
"arrays",
"stream",
"(",
"flow",
"ids",
")",
"for",
"each",
"(",
"id",
"-",
">",
"{",
"val",
"flow",
"=",
"(",
"flow",
")",
"registry",
"get",
"flow",
"definition",
"(",
"id",
")",
";",
"if",
"(",
"flow",
"!",
"=",
"null",
"&",
"&",
"contains",
"flow",
"state",
"(",
"flow",
",",
"cas",
"webflow",
"constants",
"state",
"id",
"real",
"submit",
")",
")",
"{",
"val",
"states",
"=",
"get",
"candidate",
"states",
"for",
"multifactor",
"authentication",
"(",
")",
";",
"states",
"for",
"each",
"(",
"s",
"-",
">",
"{",
"val",
"state",
"=",
"get",
"state",
"(",
"flow",
",",
"s",
")",
";",
"if",
"(",
"state",
"!",
"=",
"null",
")",
"{",
"ensure",
"end",
"state",
"transition",
"exists",
"(",
"state",
",",
"flow",
",",
"cas",
"webflow",
"constants",
"transition",
"id",
"success",
",",
"cas",
"webflow",
"constants",
"state",
"id",
"success",
")",
";",
"ensure",
"end",
"state",
"transition",
"exists",
"(",
"state",
",",
"flow",
",",
"cas",
"webflow",
"constants",
"transition",
"id",
"success",
"with",
"warnings",
",",
"cas",
"webflow",
"constants",
"transition",
"id",
"success",
"with",
"warnings",
")",
";",
"ensure",
"end",
"state",
"transition",
"exists",
"(",
"state",
",",
"flow",
",",
"cas",
"webflow",
"constants",
"transition",
"id",
"unavailable",
",",
"cas",
"webflow",
"constants",
"state",
"id",
"mfa",
"unavailable",
")",
";",
"ensure",
"end",
"state",
"transition",
"exists",
"(",
"state",
",",
"flow",
",",
"cas",
"webflow",
"constants",
"transition",
"id",
"deny",
",",
"cas",
"webflow",
"constants",
"state",
"id",
"mfa",
"denied",
")",
";",
"}",
"else",
"{",
"logger",
"debug",
"(",
"\"",
"unable",
"to",
"locate",
"state",
"definition",
"[",
"{",
"}",
"]",
"in",
"flow",
"[",
"{",
"}",
"]",
"\"",
",",
"s",
",",
"flow",
"get",
"id",
"(",
")",
")",
";",
"}",
"}",
")",
";",
"}",
"}",
")",
";",
"}",
")",
";",
"}"
]
|
[
"by",
"default",
",",
"when",
"accepting",
"untrusted",
"ssl",
"certificates",
",",
"assume",
"that",
"these",
"certificates",
"will",
"come",
"from",
"an",
"untrusted",
"issuer",
"or",
"will",
"be",
"self",
"signed",
"due",
"to",
"limitation",
"within",
"firefox",
",",
"it",
"is",
"easy",
"to",
"find",
"out",
"if",
"the",
"certificate",
"has",
"expired",
"or",
"does",
"not",
"match",
"the",
"host",
"it",
"was",
"served",
"for",
",",
"but",
"hard",
"to",
"find",
"out",
"if",
"the",
"issuer",
"of",
"the",
"certificate",
"is",
"untrusted",
"by",
"default",
",",
"it",
"is",
"assumed",
"that",
"the",
"certificates",
"were",
"not",
"be",
"issued",
"from",
"a",
"trusted",
"ca",
"if",
"you",
"are",
"receive",
"an",
"\"",
"untrusted",
"site",
"\"",
"prompt",
"on",
"firefox",
"when",
"using",
"a",
"certificate",
"that",
"was",
"issued",
"by",
"valid",
"issuer",
",",
"but",
"has",
"expired",
"or",
"is",
"being",
"served",
"served",
"for",
"a",
"different",
"host",
"(",
"e",
"g",
"production",
"certificate",
"served",
"in",
"a",
"testing",
"environment",
")",
"set",
"this",
"to",
"false"
]
| [
"public",
"void",
"set",
"assume",
"untrusted",
"certificate",
"issuer",
"(",
"boolean",
"untrusted",
"issuer",
")",
"{",
"this",
"untrusted",
"cert",
"issuer",
"=",
"untrusted",
"issuer",
";",
"}"
]
|
[
"returns",
"true",
"if",
"field",
"corresponding",
"to",
"field",
"i",
"d",
"is",
"set",
"(",
"has",
"been",
"assigned",
"a",
"value",
")",
"and",
"false",
"otherwise"
]
| [
"public",
"boolean",
"is",
"set",
"(",
"fields",
"field",
")",
"{",
"if",
"(",
"field",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
")",
";",
"}",
"switch",
"(",
"field",
")",
"{",
"case",
"arg",
":",
"return",
"is",
"set",
"arg",
"(",
")",
";",
"}",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
")",
";",
"}"
]
|
[
"swaps",
"the",
"existing",
"r",
"m",
"container",
"'",
"s",
"and",
"the",
"temp",
"r",
"m",
"containers",
"internal",
"container",
"references",
"after",
"adjusting",
"the",
"resources",
"in",
"each"
]
| [
"public",
"r",
"m",
"container",
"swap",
"container",
"(",
"r",
"m",
"container",
"temp",
"r",
"m",
"container",
",",
"r",
"m",
"container",
"existing",
"r",
"m",
"container",
",",
"container",
"update",
"type",
"update",
"type",
")",
"{",
"container",
"id",
"matched",
"container",
"id",
"=",
"existing",
"r",
"m",
"container",
"get",
"container",
"id",
"(",
")",
";",
"/",
"/",
"swap",
"updated",
"container",
"with",
"the",
"existing",
"container",
"container",
"temp",
"container",
"=",
"temp",
"r",
"m",
"container",
"get",
"container",
"(",
")",
";",
"resource",
"updated",
"resource",
"=",
"create",
"updated",
"resource",
"(",
"temp",
"container",
",",
"existing",
"r",
"m",
"container",
"get",
"container",
"(",
")",
",",
"update",
"type",
")",
";",
"resource",
"resource",
"to",
"release",
"=",
"create",
"resource",
"to",
"release",
"(",
"existing",
"r",
"m",
"container",
"get",
"container",
"(",
")",
",",
"update",
"type",
")",
";",
"container",
"new",
"container",
"=",
"container",
"new",
"instance",
"(",
"matched",
"container",
"id",
",",
"existing",
"r",
"m",
"container",
"get",
"container",
"(",
")",
"get",
"node",
"id",
"(",
")",
",",
"existing",
"r",
"m",
"container",
"get",
"container",
"(",
")",
"get",
"node",
"http",
"address",
"(",
")",
",",
"updated",
"resource",
",",
"existing",
"r",
"m",
"container",
"get",
"container",
"(",
")",
"get",
"priority",
"(",
")",
",",
"null",
",",
"temp",
"container",
"get",
"execution",
"type",
"(",
")",
")",
";",
"new",
"container",
"set",
"exposed",
"ports",
"(",
"existing",
"r",
"m",
"container",
"get",
"container",
"(",
")",
"get",
"exposed",
"ports",
"(",
")",
")",
";",
"new",
"container",
"set",
"allocation",
"request",
"id",
"(",
"existing",
"r",
"m",
"container",
"get",
"container",
"(",
")",
"get",
"allocation",
"request",
"id",
"(",
")",
")",
";",
"new",
"container",
"set",
"version",
"(",
"existing",
"r",
"m",
"container",
"get",
"container",
"(",
")",
"get",
"version",
"(",
")",
")",
";",
"temp",
"r",
"m",
"container",
"get",
"container",
"(",
")",
"set",
"resource",
"(",
"resource",
"to",
"release",
")",
";",
"temp",
"r",
"m",
"container",
"get",
"container",
"(",
")",
"set",
"execution",
"type",
"(",
"existing",
"r",
"m",
"container",
"get",
"container",
"(",
")",
"get",
"execution",
"type",
"(",
")",
")",
";",
"(",
"(",
"r",
"m",
"container",
"impl",
")",
"existing",
"r",
"m",
"container",
")",
"set",
"container",
"(",
"new",
"container",
")",
";",
"return",
"existing",
"r",
"m",
"container",
";",
"}"
]
|
[
"sets",
"the",
"map",
"of",
"environment",
"variables",
"do",
"not",
"use",
"!",
"this",
"makes",
"the",
"builder",
"ignore",
"the",
"'",
"default",
"shell",
"environment",
"'",
",",
"which",
"is",
"computed",
"from",
"the",
"-",
"-",
"action",
"env",
"command",
"line",
"option"
]
| [
"public",
"builder",
"set",
"environment",
"(",
"map",
"<",
"string",
",",
"string",
">",
"environment",
")",
"{",
"this",
"environment",
"=",
"immutable",
"map",
"copy",
"of",
"(",
"environment",
")",
";",
"this",
"use",
"default",
"shell",
"environment",
"=",
"false",
";",
"return",
"this",
";",
"}"
]
|
[
"tests",
"that",
"with",
"or",
"without",
"soft",
"-",
"deletes",
",",
"we",
"should",
"perform",
"an",
"operation",
"-",
"based",
"recovery",
"if",
"there",
"were",
"some",
"but",
"not",
"too",
"many",
"uncommitted",
"documents",
"(",
"i",
"e",
",",
"less",
"than",
"10",
"%",
"of",
"committed",
"documents",
"or",
"the",
"extra",
"translog",
")",
"before",
"we",
"restart",
"the",
"cluster",
"this",
"is",
"important",
"when",
"we",
"move",
"from",
"translog",
"based",
"to",
"retention",
"leases",
"based",
"peer",
"recoveries"
]
| [
"public",
"void",
"test",
"operation",
"based",
"recovery",
"(",
")",
"throws",
"exception",
"{",
"if",
"(",
"is",
"running",
"against",
"old",
"cluster",
"(",
")",
")",
"{",
"settings",
"builder",
"settings",
"=",
"settings",
"builder",
"(",
")",
"put",
"(",
"index",
"metadata",
"setting",
"number",
"of",
"shards",
",",
"1",
")",
"put",
"(",
"index",
"metadata",
"setting",
"number",
"of",
"replicas",
",",
"1",
")",
";",
"if",
"(",
"minimum",
"node",
"version",
"(",
")",
"before",
"(",
"version",
"v",
"8",
"0",
"0",
")",
"&",
"&",
"random",
"boolean",
"(",
")",
")",
"{",
"settings",
"put",
"(",
"index",
"settings",
"index",
"soft",
"deletes",
"setting",
"get",
"key",
"(",
")",
",",
"random",
"boolean",
"(",
")",
")",
";",
"}",
"final",
"string",
"mappings",
"=",
"random",
"boolean",
"(",
")",
"?",
"\"",
"\\",
"\"",
"source",
"\\",
"\"",
":",
"{",
"\\",
"\"",
"enabled",
"\\",
"\"",
":",
"false",
"}",
"\"",
":",
"null",
";",
"create",
"index",
"(",
"index",
",",
"settings",
"build",
"(",
")",
",",
"mappings",
")",
";",
"ensure",
"green",
"(",
"index",
")",
";",
"int",
"committed",
"docs",
"=",
"random",
"int",
"between",
"(",
"100",
",",
"200",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"committed",
"docs",
";",
"i",
"+",
"+",
")",
"{",
"index",
"document",
"(",
"integer",
"to",
"string",
"(",
"i",
")",
")",
";",
"if",
"(",
"rarely",
"(",
")",
")",
"{",
"flush",
"(",
"index",
",",
"random",
"boolean",
"(",
")",
")",
";",
"}",
"}",
"flush",
"(",
"index",
",",
"true",
")",
";",
"ensure",
"peer",
"recovery",
"retention",
"leases",
"renewed",
"and",
"synced",
"(",
"index",
")",
";",
"/",
"/",
"less",
"than",
"10",
"%",
"of",
"the",
"committed",
"docs",
"(",
"see",
"index",
"setting",
"#",
"file",
"based",
"recovery",
"threshold",
"setting",
")",
"int",
"uncommitted",
"docs",
"=",
"random",
"int",
"between",
"(",
"0",
",",
"(",
"int",
")",
"(",
"committed",
"docs",
"*",
"0",
"1",
")",
")",
";",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"uncommitted",
"docs",
";",
"i",
"+",
"+",
")",
"{",
"final",
"string",
"id",
"=",
"integer",
"to",
"string",
"(",
"random",
"int",
"between",
"(",
"1",
",",
"100",
")",
")",
";",
"index",
"document",
"(",
"id",
")",
";",
"}",
"}",
"else",
"{",
"ensure",
"green",
"(",
"index",
")",
";",
"assert",
"no",
"file",
"based",
"recovery",
"(",
"index",
",",
"n",
"-",
">",
"true",
")",
";",
"ensure",
"peer",
"recovery",
"retention",
"leases",
"renewed",
"and",
"synced",
"(",
"index",
")",
";",
"}",
"}"
]
|
[
"process",
"the",
"result",
"of",
"the",
"asynchronous",
"call",
"on",
"success",
",",
"rc",
"is",
"{",
"@",
"link",
"keeper",
"exception",
"code",
"#",
"ok",
"}",
"on",
"failure",
",",
"rc",
"is",
"set",
"to",
"the",
"corresponding",
"failure",
"code",
"in",
"{",
"@",
"link",
"keeper",
"exception",
"}",
"{",
"@",
"link",
"keeper",
"exception",
"code",
"#",
"nodeexists",
"}",
"-",
"the",
"node",
"on",
"give",
"path",
"already",
"exists",
"for",
"some",
"api",
"calls",
"{",
"@",
"link",
"keeper",
"exception",
"code",
"#",
"nonode",
"}",
"-",
"the",
"node",
"on",
"given",
"path",
"doesn",
"'",
"t",
"exist",
"for",
"some",
"api",
"calls",
"{",
"@",
"link",
"keeper",
"exception",
"code",
"#",
"nochildrenforephemerals",
"}",
"-",
"an",
"ephemeral",
"node",
"cannot",
"have",
"children",
"there",
"is",
"discussion",
"in",
"community",
"it",
"might",
"be",
"changed",
"in",
"the",
"future"
]
| [
"void",
"process",
"result",
"(",
"int",
"rc",
",",
"string",
"path",
",",
"object",
"ctx",
",",
"string",
"name",
")",
";"
]
|
[
"bucket",
"upsert",
"default",
"collection",
"mutation",
"result"
]
| [
"public",
"mutation",
"result",
"bucket",
"upsert",
"default",
"collection",
"(",
"final",
"string",
"id",
",",
"final",
"object",
"document",
",",
"final",
"upsert",
"options",
"options",
")",
"{",
"val",
"bucket",
"=",
"this",
"cluster",
"bucket",
"(",
"properties",
"get",
"bucket",
"(",
")",
")",
";",
"return",
"bucket",
"default",
"collection",
"(",
")",
"upsert",
"(",
"id",
",",
"document",
",",
"options",
")",
";",
"}"
]
|
[
"register",
"a",
"listener",
"that",
"will",
"be",
"called",
"when",
"this",
"model",
"visibility",
"has",
"changed",
"the",
"listener",
"will",
"contribute",
"to",
"this",
"model",
"'",
"s",
"hash",
"code",
"state",
"per",
"the",
"{",
"@",
"link",
"com",
"airbnb",
"epoxy",
"epoxy",
"attribute",
"option",
"#",
"do",
"not",
"hash",
"}",
"rules"
]
| [
"public",
"layout",
"overloads",
"view",
"model",
"on",
"visibility",
"changed",
"(",
"on",
"model",
"visibility",
"changed",
"listener",
"<",
"layout",
"overloads",
"view",
"model",
",",
"layout",
"overloads",
"view",
">",
"listener",
")",
"{",
"on",
"mutation",
"(",
")",
";",
"this",
"on",
"model",
"visibility",
"changed",
"listener",
"epoxy",
"generated",
"model",
"=",
"listener",
";",
"return",
"this",
";",
"}"
]
|
[
"return",
"the",
"maximum",
"number",
"of",
"page",
"links",
"to",
"a",
"few",
"pages",
"around",
"the",
"current",
"one"
]
| [
"public",
"int",
"get",
"max",
"linked",
"pages",
"(",
")",
"{",
"return",
"this",
"max",
"linked",
"pages",
";",
"}"
]
|
[
"invokes",
"with",
"{",
"@",
"code",
"receiver",
"}",
"as",
"'",
"this",
"'",
"and",
"{",
"@",
"code",
"args",
"}",
"passed",
"to",
"the",
"underlying",
"method",
"and",
"returns",
"the",
"return",
"value",
";",
"or",
"calls",
"the",
"underlying",
"constructor",
"with",
"{",
"@",
"code",
"args",
"}",
"and",
"returns",
"the",
"constructed",
"instance"
]
| [
"public",
"final",
"r",
"invoke",
"(",
"@",
"nullable",
"t",
"receiver",
",",
"object",
"args",
")",
"throws",
"invocation",
"target",
"exception",
",",
"illegal",
"access",
"exception",
"{",
"return",
"(",
"r",
")",
"invoke",
"internal",
"(",
"receiver",
",",
"check",
"not",
"null",
"(",
"args",
")",
")",
";",
"}"
]
|
[
"skips",
"from",
"the",
"peek",
"buffer"
]
| [
"private",
"int",
"skip",
"from",
"peek",
"buffer",
"(",
"int",
"length",
")",
"{",
"int",
"bytes",
"skipped",
"=",
"min",
"(",
"peek",
"buffer",
"length",
",",
"length",
")",
";",
"update",
"peek",
"buffer",
"(",
"bytes",
"skipped",
")",
";",
"return",
"bytes",
"skipped",
";",
"}"
]
|
[
"creates",
"a",
"mutable",
"{",
"@",
"code",
"compact",
"hash",
"set",
"}",
"instance",
"containing",
"the",
"given",
"elements",
"in",
"unspecified",
"order"
]
| [
"public",
"static",
"<",
"e",
">",
"compact",
"hash",
"set",
"<",
"e",
">",
"create",
"(",
"e",
"elements",
")",
"{",
"compact",
"hash",
"set",
"<",
"e",
">",
"set",
"=",
"create",
"with",
"expected",
"size",
"(",
"elements",
"length",
")",
";",
"collections",
"add",
"all",
"(",
"set",
",",
"elements",
")",
";",
"return",
"set",
";",
"}"
]
|
[
"the",
"cause",
"for",
"this",
"index",
"template",
"creation"
]
| [
"public",
"put",
"index",
"template",
"request",
"cause",
"(",
"string",
"cause",
")",
"{",
"this",
"cause",
"=",
"cause",
";",
"return",
"this",
";",
"}"
]
|
[
"return",
"the",
"maximum",
",",
"minimum",
",",
"mean",
"and",
"median",
"performance",
"for",
"model",
"&",
"bs",
"&",
"gpu",
"count",
"and",
"the",
"image",
"per",
"second",
"for",
"model",
"&",
"bs",
"&",
"gpu",
"count",
"&",
"gpu",
"combinations",
"and",
"image",
"per",
"second",
"performance",
"boost",
"comparing",
"to",
"minimum",
",",
"mean",
"and",
"media",
"value"
]
| [
"private",
"float",
"[",
"]",
"get",
"various",
"image",
"per",
"second",
"(",
"string",
"model",
",",
"int",
"bs",
",",
"int",
"gpu",
"count",
",",
"string",
"gpu",
"combinations",
")",
"{",
"float",
"[",
"]",
"result",
"=",
"new",
"float",
"[",
"8",
"]",
";",
"float",
"max",
"=",
"0",
";",
"float",
"min",
"=",
"float",
"max",
"value",
";",
"float",
"sum",
"=",
"0",
";",
"int",
"count",
"=",
"0",
";",
"float",
"wanted",
"image",
"per",
"second",
"=",
"0",
";",
"float",
"current",
"image",
"per",
"second",
";",
"array",
"list",
"<",
"float",
">",
"all",
"fps",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"for",
"(",
"data",
"record",
"dr",
":",
"get",
"data",
"set",
"(",
")",
")",
"{",
"current",
"image",
"per",
"second",
"=",
"dr",
"get",
"image",
"per",
"second",
"(",
")",
";",
"if",
"(",
"dr",
"batch",
"size",
"=",
"=",
"bs",
"&",
"&",
"model",
"equals",
"(",
"dr",
"get",
"model",
"(",
")",
")",
"&",
"&",
"gpu",
"count",
"=",
"=",
"dr",
"get",
"gpu",
"count",
"(",
")",
")",
"{",
"sum",
"+",
"=",
"current",
"image",
"per",
"second",
";",
"count",
"+",
"+",
";",
"if",
"(",
"max",
"<",
"current",
"image",
"per",
"second",
")",
"{",
"max",
"=",
"current",
"image",
"per",
"second",
";",
"}",
"if",
"(",
"min",
">",
"current",
"image",
"per",
"second",
")",
"{",
"min",
"=",
"current",
"image",
"per",
"second",
";",
"}",
"if",
"(",
"gpu",
"combinations",
"equals",
"(",
"dr",
"get",
"gpu",
"combination",
"(",
")",
")",
")",
"{",
"wanted",
"image",
"per",
"second",
"=",
"dr",
"get",
"image",
"per",
"second",
"(",
")",
";",
"}",
"all",
"fps",
"add",
"(",
"dr",
"get",
"image",
"per",
"second",
"(",
")",
")",
";",
"}",
"}",
"float",
"median",
"=",
"get",
"median",
"(",
"all",
"fps",
")",
";",
"float",
"mean",
"=",
"sum",
"/",
"count",
";",
"result",
"[",
"0",
"]",
"=",
"max",
";",
"result",
"[",
"1",
"]",
"=",
"min",
";",
"result",
"[",
"2",
"]",
"=",
"mean",
";",
"result",
"[",
"3",
"]",
"=",
"median",
";",
"result",
"[",
"4",
"]",
"=",
"wanted",
"image",
"per",
"second",
";",
"result",
"[",
"5",
"]",
"=",
"wanted",
"image",
"per",
"second",
"/",
"min",
"-",
"1",
";",
"result",
"[",
"6",
"]",
"=",
"wanted",
"image",
"per",
"second",
"/",
"mean",
"-",
"1",
";",
"result",
"[",
"7",
"]",
"=",
"wanted",
"image",
"per",
"second",
"/",
"median",
"-",
"1",
";",
"return",
"result",
";",
"}"
]
|
[
"adds",
"the",
"given",
"{",
"@",
"link",
"android",
"graphics",
"bitmap",
"}",
"if",
"it",
"is",
"eligible",
"to",
"be",
"re",
"-",
"used",
"and",
"the",
"pool",
"can",
"fit",
"it",
",",
"or",
"calls",
"{",
"@",
"link",
"bitmap",
"#",
"recycle",
"(",
")",
"}",
"on",
"the",
"bitmap",
"and",
"discards",
"it",
"callers",
"must",
"not",
"continue",
"to",
"use",
"the",
"bitmap",
"after",
"calling",
"this",
"method"
]
| [
"void",
"put",
"(",
"bitmap",
"bitmap",
")",
";"
]
|
[
"get",
"the",
"execution",
"hint"
]
| [
"public",
"string",
"execution",
"hint",
"(",
")",
"{",
"return",
"execution",
"hint",
";",
"}"
]
|
[
"converts",
"x",
"attrs",
"to",
"a",
"json",
"object"
]
| [
"private",
"static",
"map",
"x",
"attrs",
"to",
"j",
"s",
"o",
"n",
"(",
"map",
"<",
"string",
",",
"byte",
"[",
"]",
">",
"x",
"attrs",
",",
"x",
"attr",
"codec",
"encoding",
")",
"throws",
"i",
"o",
"exception",
"{",
"map",
"json",
"map",
"=",
"new",
"linked",
"hash",
"map",
"(",
")",
";",
"j",
"s",
"o",
"n",
"array",
"json",
"array",
"=",
"new",
"j",
"s",
"o",
"n",
"array",
"(",
")",
";",
"if",
"(",
"x",
"attrs",
"!",
"=",
"null",
")",
"{",
"for",
"(",
"entry",
"<",
"string",
",",
"byte",
"[",
"]",
">",
"e",
":",
"x",
"attrs",
"entry",
"set",
"(",
")",
")",
"{",
"map",
"json",
"=",
"new",
"linked",
"hash",
"map",
"(",
")",
";",
"json",
"put",
"(",
"http",
"f",
"s",
"file",
"system",
"xattr",
"name",
"json",
",",
"e",
"get",
"key",
"(",
")",
")",
";",
"if",
"(",
"e",
"get",
"value",
"(",
")",
"!",
"=",
"null",
")",
"{",
"json",
"put",
"(",
"http",
"f",
"s",
"file",
"system",
"xattr",
"value",
"json",
",",
"x",
"attr",
"codec",
"encode",
"value",
"(",
"e",
"get",
"value",
"(",
")",
",",
"encoding",
")",
")",
";",
"}",
"json",
"array",
"add",
"(",
"json",
")",
";",
"}",
"}",
"json",
"map",
"put",
"(",
"http",
"f",
"s",
"file",
"system",
"xattrs",
"json",
",",
"json",
"array",
")",
";",
"return",
"json",
"map",
";",
"}"
]
|
[
"internal",
"method",
"for",
"creating",
"label",
"symbols"
]
| [
"public",
"symbol",
"create",
"code",
"symbol",
"(",
"address",
"addr",
",",
"string",
"name",
",",
"namespace",
"namespace",
",",
"source",
"type",
"source",
",",
"string",
"data",
"3",
")",
"throws",
"invalid",
"input",
"exception",
"{",
"lock",
"acquire",
"(",
")",
";",
"try",
"{",
"namespace",
"=",
"validate",
"namespace",
"(",
"namespace",
",",
"addr",
",",
"symbol",
"type",
"label",
")",
";",
"source",
"=",
"validate",
"source",
"(",
"source",
",",
"name",
",",
"addr",
",",
"symbol",
"type",
"label",
")",
";",
"name",
"=",
"validate",
"name",
"(",
"name",
",",
"source",
")",
";",
"symbol",
"symbol",
"=",
"get",
"symbol",
"(",
"name",
",",
"addr",
",",
"namespace",
")",
";",
"if",
"(",
"symbol",
"!",
"=",
"null",
")",
"{",
"return",
"symbol",
";",
"}",
"/",
"/",
"if",
"there",
"is",
"a",
"default",
"named",
"function",
",",
"rename",
"it",
"to",
"the",
"new",
"symbol",
"name",
"symbol",
"function",
"symbol",
"=",
"try",
"updating",
"default",
"function",
"(",
"addr",
",",
"name",
",",
"namespace",
",",
"source",
")",
";",
"if",
"(",
"function",
"symbol",
"!",
"=",
"null",
")",
"{",
"return",
"function",
"symbol",
";",
"}",
"/",
"/",
"if",
"there",
"is",
"a",
"dynamic",
"symbol",
",",
"delete",
"it",
"and",
"make",
"the",
"new",
"symbol",
"primary",
"symbol",
"primary",
"=",
"get",
"primary",
"symbol",
"(",
"addr",
")",
";",
"if",
"(",
"primary",
"!",
"=",
"null",
"&",
"&",
"primary",
"is",
"dynamic",
"(",
")",
")",
"{",
"delete",
"dynamic",
"symbol",
"(",
"primary",
")",
";",
"primary",
"=",
"null",
";",
"}",
"boolean",
"make",
"primary",
"=",
"primary",
"=",
"=",
"null",
";",
"return",
"do",
"create",
"symbol",
"(",
"name",
",",
"addr",
",",
"namespace",
",",
"symbol",
"type",
"label",
",",
"-",
"1",
",",
"make",
"primary",
"?",
"1",
":",
"0",
",",
"data",
"3",
",",
"source",
")",
";",
"}",
"finally",
"{",
"lock",
"release",
"(",
")",
";",
"}",
"}"
]
|
[
"returns",
"an",
"array",
"containing",
"the",
"start",
"offsets",
"of",
"the",
"files",
"in",
"the",
"split"
]
| [
"public",
"long",
"[",
"]",
"get",
"start",
"offsets",
"(",
")",
"{",
"return",
"startoffset",
";",
"}"
]
|
[
"tells",
"whether",
"the",
"function",
"has",
"buffer",
"security",
"check",
"due",
"to",
"gs"
]
| [
"public",
"boolean",
"has",
"gs",
"buffer",
"security",
"check",
"(",
")",
"{",
"return",
"has",
"gs",
"buffer",
"security",
"check",
";",
"}"
]
|
[
"get",
"user",
"account",
"using",
"read",
"-",
"through",
"cache",
"with",
"write",
"-",
"back",
"policy"
]
| [
"public",
"static",
"user",
"account",
"read",
"through",
"with",
"write",
"back",
"policy",
"(",
"string",
"user",
"id",
")",
"{",
"if",
"(",
"cache",
"contains",
"(",
"user",
"id",
")",
")",
"{",
"logger",
"info",
"(",
"\"",
"#",
"cache",
"hit",
"!",
"\"",
")",
";",
"return",
"cache",
"get",
"(",
"user",
"id",
")",
";",
"}",
"logger",
"info",
"(",
"\"",
"#",
"cache",
"miss",
"!",
"\"",
")",
";",
"user",
"account",
"user",
"account",
"=",
"db",
"manager",
"read",
"from",
"db",
"(",
"user",
"id",
")",
";",
"if",
"(",
"cache",
"is",
"full",
"(",
")",
")",
"{",
"logger",
"info",
"(",
"\"",
"#",
"cache",
"is",
"full",
"!",
"writing",
"lru",
"data",
"to",
"db",
"\"",
")",
";",
"user",
"account",
"to",
"be",
"written",
"to",
"db",
"=",
"cache",
"get",
"lru",
"data",
"(",
")",
";",
"db",
"manager",
"upsert",
"db",
"(",
"to",
"be",
"written",
"to",
"db",
")",
";",
"}",
"cache",
"set",
"(",
"user",
"id",
",",
"user",
"account",
")",
";",
"return",
"user",
"account",
";",
"}"
]
|
[
"add",
"converter",
"factory",
"for",
"serialization",
"and",
"deserialization",
"of",
"objects"
]
| [
"public",
"builder",
"add",
"converter",
"factory",
"(",
"converter",
"factory",
"factory",
")",
"{",
"converter",
"factories",
"add",
"(",
"objects",
"require",
"non",
"null",
"(",
"factory",
",",
"\"",
"factory",
"=",
"=",
"null",
"\"",
")",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
]
| [
"private",
"string",
"to",
"indented",
"string",
"(",
"java",
"lang",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
]
|
[
"finalize",
"write",
"of",
"channel",
"state",
"data",
"for",
"the",
"given",
"checkpoint",
"id",
"must",
"be",
"called",
"after",
"{",
"@",
"link",
"#",
"start",
"(",
"long",
",",
"checkpoint",
"options",
")",
"}",
"and",
"all",
"of",
"the",
"output",
"data",
"of",
"the",
"given",
"checkpoint",
"added",
"when",
"both",
"{",
"@",
"link",
"#",
"finish",
"input",
"}",
"and",
"{",
"@",
"link",
"#",
"finish",
"output",
"}",
"were",
"called",
"the",
"results",
"can",
"be",
"(",
"eventually",
")",
"obtained",
"using",
"{",
"@",
"link",
"#",
"get",
"and",
"remove",
"write",
"result",
"}"
]
| [
"void",
"finish",
"output",
"(",
"long",
"checkpoint",
"id",
")",
";"
]
|
[
"this",
"test",
"checks",
"that",
"choose",
"random",
"works",
"for",
"a",
"list",
"of",
"excluded",
"nodes"
]
| [
"public",
"void",
"test",
"choose",
"random",
"excluded",
"node",
"list",
"(",
")",
"{",
"string",
"scope",
"=",
"\"",
"~",
"\"",
"+",
"node",
"base",
"get",
"path",
"(",
"data",
"nodes",
"[",
"0",
"]",
")",
";",
"set",
"<",
"node",
">",
"excluded",
"nodes",
"=",
"new",
"hash",
"set",
"<",
">",
"(",
")",
";",
"excluded",
"nodes",
"add",
"(",
"data",
"nodes",
"[",
"3",
"]",
")",
";",
"excluded",
"nodes",
"add",
"(",
"data",
"nodes",
"[",
"5",
"]",
")",
";",
"excluded",
"nodes",
"add",
"(",
"data",
"nodes",
"[",
"7",
"]",
")",
";",
"excluded",
"nodes",
"add",
"(",
"data",
"nodes",
"[",
"9",
"]",
")",
";",
"excluded",
"nodes",
"add",
"(",
"data",
"nodes",
"[",
"13",
"]",
")",
";",
"excluded",
"nodes",
"add",
"(",
"data",
"nodes",
"[",
"18",
"]",
")",
";",
"map",
"<",
"node",
",",
"integer",
">",
"frequency",
"=",
"pick",
"nodes",
"at",
"random",
"(",
"100",
",",
"scope",
",",
"excluded",
"nodes",
")",
";",
"assert",
"equals",
"(",
"\"",
"dn",
"[",
"3",
"]",
"should",
"be",
"excluded",
"\"",
",",
"0",
",",
"frequency",
"get",
"(",
"data",
"nodes",
"[",
"3",
"]",
")",
"int",
"value",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"dn",
"[",
"5",
"]",
"should",
"be",
"exclude",
"1",
"8d",
"\"",
",",
"0",
",",
"frequency",
"get",
"(",
"data",
"nodes",
"[",
"5",
"]",
")",
"int",
"value",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"dn",
"[",
"7",
"]",
"should",
"be",
"excluded",
"\"",
",",
"0",
",",
"frequency",
"get",
"(",
"data",
"nodes",
"[",
"7",
"]",
")",
"int",
"value",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"dn",
"[",
"9",
"]",
"should",
"be",
"excluded",
"\"",
",",
"0",
",",
"frequency",
"get",
"(",
"data",
"nodes",
"[",
"9",
"]",
")",
"int",
"value",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"dn",
"[",
"13",
"]",
"should",
"be",
"excluded",
"\"",
",",
"0",
",",
"frequency",
"get",
"(",
"data",
"nodes",
"[",
"13",
"]",
")",
"int",
"value",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"dn",
"[",
"18",
"]",
"should",
"be",
"excluded",
"\"",
",",
"0",
",",
"frequency",
"get",
"(",
"data",
"nodes",
"[",
"18",
"]",
")",
"int",
"value",
"(",
")",
")",
";",
"for",
"(",
"node",
"key",
":",
"data",
"nodes",
")",
"{",
"if",
"(",
"excluded",
"nodes",
"contains",
"(",
"key",
")",
")",
"{",
"continue",
";",
"}",
"/",
"/",
"all",
"nodes",
"except",
"the",
"first",
"should",
"be",
"more",
"than",
"zero",
"assert",
"true",
"(",
"frequency",
"get",
"(",
"key",
")",
">",
"0",
"|",
"|",
"key",
"=",
"=",
"data",
"nodes",
"[",
"0",
"]",
")",
";",
"}",
"}"
]
|
[
"test",
"that",
"the",
"jaas",
"config",
"file",
"is",
"created",
"in",
"the",
"working",
"directory"
]
| [
"private",
"void",
"test",
"jaas",
"module",
"file",
"path",
"(",
"string",
"working",
"dir",
")",
"throws",
"i",
"o",
"exception",
"{",
"configuration",
"configuration",
"=",
"new",
"configuration",
"(",
")",
";",
"/",
"/",
"set",
"the",
"string",
"for",
"core",
"options",
"tmp",
"dirs",
"to",
"mock",
"the",
"working",
"directory",
"configuration",
"set",
"string",
"(",
"core",
"options",
"tmp",
"dirs",
",",
"working",
"dir",
")",
";",
"security",
"configuration",
"sc",
"=",
"new",
"security",
"configuration",
"(",
"configuration",
")",
";",
"jaas",
"module",
"module",
"=",
"new",
"jaas",
"module",
"(",
"sc",
")",
";",
"module",
"install",
"(",
")",
";",
"assert",
"jaas",
"file",
"locate",
"in",
"right",
"directory",
"(",
"working",
"dir",
")",
";",
"}"
]
|
[
"assert",
"the",
"servlet",
"response",
"error",
"message"
]
| [
"public",
"result",
"matcher",
"reason",
"(",
"string",
"reason",
")",
"{",
"return",
"result",
"-",
">",
"assert",
"equals",
"(",
"\"",
"response",
"status",
"reason",
"\"",
",",
"reason",
",",
"result",
"get",
"response",
"(",
")",
"get",
"error",
"message",
"(",
")",
")",
";",
"}"
]
|
[
"builds",
"camera",
"motion",
"renderers",
"for",
"use",
"by",
"the",
"player"
]
| [
"protected",
"void",
"build",
"camera",
"motion",
"renderers",
"(",
"context",
"context",
",",
"@",
"extension",
"renderer",
"mode",
"int",
"extension",
"renderer",
"mode",
",",
"array",
"list",
"<",
"renderer",
">",
"out",
")",
"{",
"out",
"add",
"(",
"new",
"camera",
"motion",
"renderer",
"(",
")",
")",
";",
"}"
]
|
[
"returns",
"the",
"index",
"in",
"the",
"buffer",
"of",
"the",
"end",
"of",
"line",
"found",
"returns",
"-",
"1",
"if",
"no",
"end",
"of",
"line",
"was",
"found",
"in",
"the",
"buffer"
]
| [
"private",
"int",
"find",
"end",
"of",
"line",
"(",
"final",
"byte",
"buf",
"buffer",
")",
"{",
"int",
"total",
"length",
"=",
"buffer",
"readable",
"bytes",
"(",
")",
";",
"int",
"i",
"=",
"buffer",
"for",
"each",
"byte",
"(",
"buffer",
"reader",
"index",
"(",
")",
"+",
"offset",
",",
"total",
"length",
"-",
"offset",
",",
"byte",
"processor",
"find",
"lf",
")",
";",
"if",
"(",
"i",
">",
"=",
"0",
")",
"{",
"offset",
"=",
"0",
";",
"if",
"(",
"i",
">",
"0",
"&",
"&",
"buffer",
"get",
"byte",
"(",
"i",
"-",
"1",
")",
"=",
"=",
"'",
"\\",
"r",
"'",
")",
"{",
"i",
"-",
"-",
";",
"}",
"}",
"else",
"{",
"offset",
"=",
"total",
"length",
";",
"}",
"return",
"i",
";",
"}"
]
|
[
"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",
";",
"}"
]
|
[
"logs",
"the",
"given",
"request",
"if",
"request",
"tracing",
"is",
"enabled",
"and",
"the",
"request",
"uri",
"matches",
"the",
"current",
"include",
"and",
"exclude",
"patterns",
"defined",
"in",
"{",
"@",
"link",
"http",
"transport",
"settings",
"#",
"setting",
"http",
"trace",
"log",
"include",
"}",
"and",
"{",
"@",
"link",
"http",
"transport",
"settings",
"#",
"setting",
"http",
"trace",
"log",
"exclude",
"}",
"if",
"the",
"request",
"was",
"logged",
"returns",
"a",
"logger",
"to",
"log",
"sending",
"the",
"response",
"with",
"or",
"{",
"@",
"code",
"null",
"}",
"otherwise"
]
| [
"http",
"tracer",
"maybe",
"trace",
"request",
"(",
"rest",
"request",
"rest",
"request",
",",
"@",
"nullable",
"exception",
"e",
")",
"{",
"if",
"(",
"logger",
"is",
"trace",
"enabled",
"(",
")",
"&",
"&",
"transport",
"service",
"should",
"trace",
"action",
"(",
"rest",
"request",
"uri",
"(",
")",
",",
"tracer",
"log",
"include",
",",
"tracer",
"log",
"exclude",
")",
")",
"{",
"logger",
"trace",
"(",
"new",
"parameterized",
"message",
"(",
"\"",
"[",
"{",
"}",
"]",
"[",
"{",
"}",
"]",
"[",
"{",
"}",
"]",
"[",
"{",
"}",
"]",
"received",
"request",
"from",
"[",
"{",
"}",
"]",
"\"",
",",
"rest",
"request",
"get",
"request",
"id",
"(",
")",
",",
"rest",
"request",
"header",
"(",
"task",
"x",
"opaque",
"id",
")",
",",
"rest",
"request",
"method",
"(",
")",
",",
"rest",
"request",
"uri",
"(",
")",
",",
"rest",
"request",
"get",
"http",
"channel",
"(",
")",
")",
",",
"e",
")",
";",
"return",
"this",
";",
"}",
"return",
"null",
";",
"}"
]
|
[
"checks",
"if",
"sort",
"channel",
"is",
"null",
"at",
"the",
"specified",
"position"
]
| [
"boolean",
"is",
"sort",
"channel",
"position",
"null",
"(",
"int",
"block",
"index",
",",
"int",
"block",
"position",
")",
";"
]
|
[
"sets",
"the",
"text",
"alignment",
"of",
"the",
"description",
"text",
"default",
"right"
]
| [
"public",
"void",
"set",
"text",
"align",
"(",
"paint",
"align",
"align",
")",
"{",
"this",
"m",
"text",
"align",
"=",
"align",
";",
"}"
]
|
[
"retrieves",
"a",
"{",
"@",
"link",
"parser",
"}",
"that",
"provides",
"methods",
"for",
"parsing",
"a",
"sql",
"string"
]
| [
"parser",
"get",
"parser",
"(",
")",
";"
]
|
[
"get",
"the",
"checksum",
"of",
"the",
"source",
"files",
"from",
"which",
"yarn",
"was",
"built"
]
| [
"public",
"static",
"string",
"get",
"src",
"checksum",
"(",
")",
"{",
"return",
"yarn",
"version",
"info",
"get",
"src",
"checksum",
"(",
")",
";",
"}"
]
|
[
"enter",
"a",
"parse",
"tree",
"produced",
"by",
"{",
"@",
"link",
"sql",
"base",
"parser",
"#",
"single",
"statement",
"}"
]
| [
"void",
"enter",
"single",
"statement",
"(",
"sql",
"base",
"parser",
"single",
"statement",
"context",
"ctx",
")",
";"
]
|
[
"test",
"the",
"property",
"'",
"attribute",
"boolean",
"'"
]
| [
"public",
"void",
"attribute",
"boolean",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"attribute",
"boolean",
"}"
]
|
[
"this",
"method",
"can",
"be",
"called",
"by",
"a",
"model",
"'",
"s",
"get",
"methods",
"to",
"validate",
"the",
"model",
"before",
"trying",
"to",
"retrieve",
"a",
"particular",
"piece",
"of",
"information",
"<",
"br",
">",
"important",
":",
"this",
"method",
"must",
"not",
"be",
"called",
"by",
"any",
"methods",
"that",
"are",
"called",
"(",
"possibly",
"indirectly",
")",
"by",
"the",
"model",
"'",
"s",
"validate",
"model",
"specific",
"info",
"(",
")",
"method"
]
| [
"protected",
"void",
"check",
"validity",
"(",
")",
"throws",
"invalid",
"data",
"type",
"exception",
"{",
"if",
"(",
"!",
"is",
"valid",
"(",
")",
")",
"{",
"throw",
"new",
"invalid",
"data",
"type",
"exception",
"(",
"get",
"name",
"(",
")",
"+",
"\"",
"data",
"type",
"isn",
"'",
"t",
"valid",
"at",
"\"",
"+",
"get",
"address",
"(",
")",
"+",
"\"",
"in",
"\"",
"+",
"get",
"program",
"(",
")",
"+",
"\"",
"\"",
")",
";",
"}",
"}"
]
|
[
"filter",
"out",
"jaccard",
"index",
"scores",
"less",
"than",
"the",
"given",
"minimum",
"fraction"
]
| [
"public",
"jaccard",
"index",
"<",
"k",
",",
"vv",
",",
"ev",
">",
"set",
"minimum",
"score",
"(",
"int",
"numerator",
",",
"int",
"denominator",
")",
"{",
"preconditions",
"check",
"argument",
"(",
"numerator",
">",
"=",
"0",
",",
"\"",
"minimum",
"score",
"numerator",
"must",
"be",
"non",
"-",
"negative",
"\"",
")",
";",
"preconditions",
"check",
"argument",
"(",
"denominator",
">",
"0",
",",
"\"",
"minimum",
"score",
"denominator",
"must",
"be",
"greater",
"than",
"zero",
"\"",
")",
";",
"preconditions",
"check",
"argument",
"(",
"numerator",
"<",
"=",
"denominator",
",",
"\"",
"minimum",
"score",
"fraction",
"must",
"be",
"less",
"than",
"or",
"equal",
"to",
"one",
"\"",
")",
";",
"this",
"unbounded",
"scores",
"=",
"false",
";",
"this",
"minimum",
"score",
"numerator",
"=",
"numerator",
";",
"this",
"minimum",
"score",
"denominator",
"=",
"denominator",
";",
"return",
"this",
";",
"}"
]
|
[
"http",
":",
"tools",
"ietf",
"orghtmldraft",
"-",
"ietf",
"-",
"httpbis",
"-",
"header",
"-",
"compression",
"-",
"12",
"#",
"appendix",
"-",
"c",
"2",
"2"
]
| [
"@",
"test",
"public",
"void",
"literal",
"header",
"field",
"without",
"indexing",
"indexed",
"name",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"list",
"<",
"header",
">",
"header",
"block",
"=",
"header",
"entries",
"(",
"\"",
":",
"path",
"\"",
",",
"\"",
"/",
"sample",
"/",
"path",
"\"",
")",
";",
"bytes",
"in",
"write",
"byte",
"(",
"0x",
"0",
"4",
")",
";",
"/",
"/",
"=",
"=",
"literal",
"not",
"indexed",
"=",
"=",
"/",
"/",
"indexed",
"name",
"(",
"idx",
"=",
"4",
")",
"-",
">",
":",
"path",
"bytes",
"in",
"write",
"byte",
"(",
"0x",
"0c",
")",
";",
"/",
"/",
"literal",
"value",
"(",
"len",
"=",
"12",
")",
"bytes",
"in",
"write",
"utf",
"8",
"(",
"\"",
"/",
"sample",
"/",
"path",
"\"",
")",
";",
"hpack",
"writer",
"write",
"headers",
"(",
"header",
"block",
")",
";",
"assert",
"equals",
"(",
"bytes",
"in",
",",
"bytes",
"out",
")",
";",
"hpack",
"reader",
"read",
"headers",
"(",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"hpack",
"reader",
"dynamic",
"table",
"header",
"count",
")",
";",
"assert",
"equals",
"(",
"header",
"block",
",",
"hpack",
"reader",
"get",
"and",
"reset",
"header",
"list",
"(",
")",
")",
";",
"}"
]
|
[
"invoked",
"from",
"a",
"container",
"thread",
"when",
"async",
"processing",
"completes",
"for",
"any",
"reason",
"including",
"timeout",
"or",
"network",
"error",
"the",
"default",
"implementation",
"is",
"empty"
]
| [
"default",
"<",
"t",
">",
"void",
"after",
"completion",
"(",
"native",
"web",
"request",
"request",
",",
"callable",
"<",
"t",
">",
"task",
")",
"throws",
"exception",
"{",
"}"
]
|
[
"gets",
"a",
"derived",
"artifact",
"for",
"testing",
"in",
"the",
"subdirectory",
"of",
"the",
"{",
"@",
"link",
"build",
"configuration",
"#",
"get",
"include",
"directory",
"}",
"corresponding",
"to",
"the",
"package",
"of",
"{",
"@",
"code",
"owner",
"}",
"so",
"to",
"specify",
"a",
"file",
"foofoo",
"o",
"owned",
"by",
"target",
"foo",
":",
"foo",
",",
"{",
"@",
"code",
"package",
"relative",
"path",
"}",
"should",
"just",
"be",
"\"",
"foo",
"h",
"\""
]
| [
"protected",
"artifact",
"get",
"include",
"artifact",
"(",
"string",
"package",
"relative",
"path",
",",
"string",
"owner",
")",
"{",
"return",
"get",
"include",
"artifact",
"(",
"package",
"relative",
"path",
",",
"make",
"configured",
"target",
"key",
"(",
"owner",
")",
")",
";",
"}"
]
|
[
"implementers",
"should",
"implement",
"this",
"method",
"as",
"they",
"normally",
"would",
"for",
"{",
"@",
"link",
"base",
"rest",
"handler",
"#",
"prepare",
"request",
"(",
"rest",
"request",
",",
"node",
"client",
")",
"}",
"and",
"ensure",
"that",
"all",
"request",
"parameters",
"are",
"consumed",
"prior",
"to",
"returning",
"a",
"value",
"the",
"returned",
"value",
"is",
"not",
"guaranteed",
"to",
"be",
"executed",
"unless",
"security",
"is",
"licensed",
"and",
"all",
"request",
"parameters",
"are",
"known"
]
| [
"protected",
"abstract",
"rest",
"channel",
"consumer",
"inner",
"prepare",
"request",
"(",
"rest",
"request",
"request",
",",
"node",
"client",
"client",
")",
"throws",
"i",
"o",
"exception",
";"
]
|
[
"recursively",
"get",
"the",
"key",
"with",
"the",
"given",
"hash"
]
| [
"abstract",
"v",
"get",
"(",
"object",
"key",
",",
"int",
"hash",
")",
";"
]
|
[
"gets",
"the",
"{",
"@",
"link",
"standard",
"socket",
"options",
"#",
"so",
"keepalive",
"}",
"option"
]
| [
"boolean",
"is",
"keep",
"alive",
"(",
")",
";"
]
|
[
"returns",
"prepared",
"statements",
"for",
"enumeration",
"fetch"
]
| [
"public",
"list",
"<",
"d",
"b",
"d",
"label",
"value",
"pair",
">",
"get",
"dictionary",
"enumeration",
"(",
"@",
"not",
"null",
"d",
"b",
"r",
"progress",
"monitor",
"monitor",
",",
"@",
"not",
"null",
"d",
"b",
"s",
"entity",
"attribute",
"key",
"column",
",",
"object",
"key",
"pattern",
",",
"list",
"<",
"d",
"b",
"d",
"attribute",
"value",
">",
"preceeding",
"keys",
",",
"boolean",
"sort",
"by",
"value",
",",
"boolean",
"sort",
"asc",
",",
"int",
"max",
"results",
")",
"throws",
"d",
"b",
"exception",
"{",
"/",
"/",
"use",
"default",
"one",
"return",
"read",
"key",
"enumeration",
"(",
"monitor",
",",
"key",
"column",
",",
"key",
"pattern",
",",
"preceeding",
"keys",
",",
"sort",
"by",
"value",
",",
"sort",
"asc",
",",
"max",
"results",
")",
";",
"}"
]
|
[
"sets",
"the",
"min",
"width",
",",
"pref",
"width",
",",
"max",
"width",
",",
"min",
"height",
",",
"pref",
"height",
",",
"and",
"max",
"height",
"to",
"the",
"specified",
"values"
]
| [
"public",
"container",
"<",
"t",
">",
"size",
"(",
"float",
"width",
",",
"float",
"height",
")",
"{",
"size",
"(",
"fixed",
"value",
"of",
"(",
"width",
")",
",",
"fixed",
"value",
"of",
"(",
"height",
")",
")",
";",
"return",
"this",
";",
"}"
]
|
[
"checks",
"if",
"writing",
"{",
"@",
"code",
"len",
"}",
"bytes",
"would",
"go",
"over",
"threshold",
",",
"and",
"switches",
"to",
"file",
"buffering",
"if",
"so"
]
| [
"private",
"void",
"update",
"(",
"int",
"len",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"file",
"=",
"=",
"null",
"&",
"&",
"(",
"memory",
"get",
"count",
"(",
")",
"+",
"len",
">",
"file",
"threshold",
")",
")",
"{",
"file",
"temp",
"=",
"file",
"create",
"temp",
"file",
"(",
"\"",
"file",
"backed",
"output",
"stream",
"\"",
",",
"null",
",",
"parent",
"directory",
")",
";",
"if",
"(",
"reset",
"on",
"finalize",
")",
"{",
"/",
"/",
"finalizers",
"are",
"not",
"guaranteed",
"to",
"be",
"called",
"on",
"system",
"shutdown",
";",
"/",
"/",
"this",
"is",
"insurance",
"temp",
"delete",
"on",
"exit",
"(",
")",
";",
"}",
"file",
"output",
"stream",
"transfer",
"=",
"new",
"file",
"output",
"stream",
"(",
"temp",
")",
";",
"transfer",
"write",
"(",
"memory",
"get",
"buffer",
"(",
")",
",",
"0",
",",
"memory",
"get",
"count",
"(",
")",
")",
";",
"transfer",
"flush",
"(",
")",
";",
"/",
"/",
"we",
"'",
"ve",
"successfully",
"transferred",
"the",
"data",
";",
"switch",
"to",
"writing",
"to",
"file",
"out",
"=",
"transfer",
";",
"file",
"=",
"temp",
";",
"memory",
"=",
"null",
";",
"}",
"}"
]
|
[
"gets",
"the",
"associated",
"annotations"
]
| [
"public",
"annotations",
"get",
"annotations",
"(",
")",
"{",
"return",
"annotations",
"get",
"annotations",
"(",
")",
";",
"}"
]
|
[
"initializes",
"the",
"wrapper",
"with",
"the",
"specified",
"parameters"
]
| [
"public",
"synchronized",
"void",
"init",
"(",
"request",
"interceptor",
"root",
"interceptor",
",",
"application",
"attempt",
"id",
"application",
"attempt",
"id",
")",
"{",
"this",
"root",
"interceptor",
"=",
"root",
"interceptor",
";",
"this",
"application",
"attempt",
"id",
"=",
"application",
"attempt",
"id",
";",
"}"
]
|
[
"delete",
"a",
"specific",
"bookmark"
]
| [
"void",
"delete",
"record",
"(",
"long",
"id",
")",
"throws",
"i",
"o",
"exception",
"{",
"throw",
"new",
"unsupported",
"operation",
"exception",
"(",
"\"",
"bookmarks",
"are",
"read",
"-",
"only",
"and",
"may",
"not",
"be",
"deleted",
"\"",
")",
";",
"}"
]
|
[
"get",
"the",
"key",
"of",
"the",
"destination",
"\"",
"directory",
"\"",
"of",
"the",
"jobtask"
]
| [
"private",
"string",
"get",
"s",
"3",
"key",
"prefix",
"(",
"job",
"context",
"context",
")",
"{",
"return",
"s",
"3",
"key",
"prefix",
";",
"}"
]
|
[
"adds",
"a",
"route",
"to",
"the",
"given",
"handler",
"function",
"that",
"handles",
"all",
"requests",
"that",
"match",
"the",
"given",
"predicate"
]
| [
"builder",
"route",
"(",
"request",
"predicate",
"predicate",
",",
"handler",
"function",
"<",
"server",
"response",
">",
"handler",
"function",
")",
";"
]
|
[
"generate",
"pcode",
"for",
"a",
"getfield",
"op"
]
| [
"public",
"static",
"void",
"get",
"pcode",
"for",
"get",
"field",
"(",
"pcode",
"op",
"emitter",
"p",
"code",
",",
"int",
"index",
",",
"abstract",
"constant",
"pool",
"info",
"java",
"[",
"]",
"constant",
"pool",
")",
"{",
"string",
"descriptor",
"=",
"get",
"descriptor",
"for",
"field",
"ref",
"(",
"constant",
"pool",
",",
"index",
")",
";",
"switch",
"(",
"descriptor",
"char",
"at",
"(",
"0",
")",
")",
"{",
"case",
"descriptor",
"decoder",
"base",
"type",
"byte",
":",
"/",
"/",
"signed",
"byte",
"p",
"code",
"emit",
"pop",
"cat",
"1",
"value",
"(",
"object",
"ref",
")",
";",
"p",
"code",
"emit",
"assign",
"varnode",
"from",
"pcode",
"op",
"call",
"(",
"temp",
"1",
",",
"1",
",",
"constant",
"pool",
"java",
"cpool",
"op",
",",
"object",
"ref",
",",
"integer",
"to",
"string",
"(",
"index",
")",
",",
"constant",
"pool",
"java",
"cpool",
"getfield",
")",
";",
"p",
"code",
"emit",
"assign",
"varnode",
"from",
"dereference",
"(",
"temp",
"2",
",",
"1",
",",
"temp",
"1",
")",
";",
"p",
"code",
"emit",
"sign",
"extension",
"(",
"value",
",",
"4",
",",
"temp",
"2",
")",
";",
"p",
"code",
"emit",
"push",
"cat",
"1",
"value",
"(",
"value",
")",
";",
"break",
";",
"case",
"descriptor",
"decoder",
"base",
"type",
"boolean",
":",
"/",
"/",
"boolean",
"p",
"code",
"emit",
"pop",
"cat",
"1",
"value",
"(",
"object",
"ref",
")",
";",
"p",
"code",
"emit",
"assign",
"varnode",
"from",
"pcode",
"op",
"call",
"(",
"temp",
"1",
",",
"1",
",",
"constant",
"pool",
"java",
"cpool",
"op",
",",
"object",
"ref",
",",
"integer",
"to",
"string",
"(",
"index",
")",
",",
"constant",
"pool",
"java",
"cpool",
"getfield",
")",
";",
"p",
"code",
"emit",
"assign",
"varnode",
"from",
"dereference",
"(",
"temp",
"2",
",",
"1",
",",
"temp",
"1",
")",
";",
"p",
"code",
"emit",
"zero",
"extension",
"(",
"value",
",",
"4",
",",
"temp",
"2",
")",
";",
"p",
"code",
"emit",
"push",
"cat",
"1",
"value",
"(",
"value",
")",
";",
"break",
";",
"case",
"descriptor",
"decoder",
"base",
"type",
"char",
":",
"/",
"/",
"char",
"p",
"code",
"emit",
"pop",
"cat",
"1",
"value",
"(",
"object",
"ref",
")",
";",
"p",
"code",
"emit",
"assign",
"varnode",
"from",
"pcode",
"op",
"call",
"(",
"temp",
"1",
",",
"2",
",",
"constant",
"pool",
"java",
"cpool",
"op",
",",
"object",
"ref",
",",
"integer",
"to",
"string",
"(",
"index",
")",
",",
"constant",
"pool",
"java",
"cpool",
"getfield",
")",
";",
"p",
"code",
"emit",
"assign",
"varnode",
"from",
"dereference",
"(",
"temp",
"2",
",",
"2",
",",
"temp",
"1",
")",
";",
"p",
"code",
"emit",
"zero",
"extension",
"(",
"value",
",",
"4",
",",
"temp",
"2",
")",
";",
"p",
"code",
"emit",
"push",
"cat",
"1",
"value",
"(",
"value",
")",
";",
"break",
";",
"case",
"descriptor",
"decoder",
"base",
"type",
"short",
":",
"/",
"/",
"signed",
"short",
"p",
"code",
"emit",
"pop",
"cat",
"1",
"value",
"(",
"object",
"ref",
")",
";",
"p",
"code",
"emit",
"assign",
"varnode",
"from",
"pcode",
"op",
"call",
"(",
"temp",
"1",
",",
"2",
",",
"constant",
"pool",
"java",
"cpool",
"op",
",",
"object",
"ref",
",",
"integer",
"to",
"string",
"(",
"index",
")",
",",
"constant",
"pool",
"java",
"cpool",
"getfield",
")",
";",
"p",
"code",
"emit",
"assign",
"varnode",
"from",
"dereference",
"(",
"temp",
"2",
",",
"2",
",",
"temp",
"1",
")",
";",
"p",
"code",
"emit",
"sign",
"extension",
"(",
"value",
",",
"4",
",",
"temp",
"2",
")",
";",
"p",
"code",
"emit",
"push",
"cat",
"1",
"value",
"(",
"value",
")",
";",
"break",
";",
"case",
"descriptor",
"decoder",
"base",
"type",
"array",
":",
"/",
"/",
"array",
"dimension",
"case",
"descriptor",
"decoder",
"base",
"type",
"float",
":",
"/",
"/",
"float",
"case",
"descriptor",
"decoder",
"base",
"type",
"int",
":",
"/",
"/",
"int",
"case",
"descriptor",
"decoder",
"base",
"type",
"reference",
":",
"/",
"/",
"object",
"reference",
"p",
"code",
"emit",
"pop",
"cat",
"1",
"value",
"(",
"object",
"ref",
")",
";",
"p",
"code",
"emit",
"assign",
"varnode",
"from",
"pcode",
"op",
"call",
"(",
"temp",
"1",
",",
"4",
",",
"constant",
"pool",
"java",
"cpool",
"op",
",",
"object",
"ref",
",",
"integer",
"to",
"string",
"(",
"index",
")",
",",
"constant",
"pool",
"java",
"cpool",
"getfield",
")",
";",
"p",
"code",
"emit",
"assign",
"varnode",
"from",
"dereference",
"(",
"value",
",",
"4",
",",
"temp",
"1",
")",
";",
"p",
"code",
"emit",
"push",
"cat",
"1",
"value",
"(",
"value",
")",
";",
"break",
";",
"case",
"descriptor",
"decoder",
"base",
"type",
"double",
":",
"/",
"/",
"double",
"case",
"descriptor",
"decoder",
"base",
"type",
"long",
":",
"/",
"/",
"long",
"p",
"code",
"emit",
"pop",
"cat",
"1",
"value",
"(",
"object",
"ref",
")",
";",
"p",
"code",
"emit",
"assign",
"varnode",
"from",
"pcode",
"op",
"call",
"(",
"temp",
"1",
",",
"8",
",",
"constant",
"pool",
"java",
"cpool",
"op",
",",
"object",
"ref",
",",
"integer",
"to",
"string",
"(",
"index",
")",
",",
"constant",
"pool",
"java",
"cpool",
"getfield",
")",
";",
"p",
"code",
"emit",
"assign",
"varnode",
"from",
"dereference",
"(",
"value",
",",
"8",
",",
"temp",
"1",
")",
";",
"p",
"code",
"emit",
"push",
"cat",
"2",
"value",
"(",
"value",
")",
";",
"break",
";",
"default",
":",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"invalid",
"descriptor",
":",
"\"",
"+",
"descriptor",
")",
";",
"}",
"}"
]
|
[
"no",
"op",
"throttled",
"submission",
"handler",
"interceptor"
]
| [
"static",
"throttled",
"submission",
"handler",
"interceptor",
"no",
"op",
"(",
")",
"{",
"return",
"new",
"throttled",
"submission",
"handler",
"interceptor",
"(",
")",
"{",
"}",
";",
"}"
]
|
[
"returns",
"the",
"data",
"of",
"the",
"http",
"response",
"as",
"an",
"{",
"@",
"link",
"input",
"stream",
"}",
"<",
"b",
">",
"<",
"br",
">",
"warning",
":",
"<",
"b",
">",
"do",
"not",
"store",
"a",
"reference",
"to",
"this",
"input",
"stream",
"outside",
"of",
"{",
"@",
"link",
"http",
"response",
"listener",
"#",
"handle",
"http",
"response",
"(",
"http",
"response",
")",
"}",
"the",
"underlying",
"http",
"connection",
"will",
"be",
"closed",
"after",
"that",
"callback",
"finishes",
"executing",
"reading",
"from",
"the",
"input",
"stream",
"after",
"it",
"'",
"s",
"connection",
"has",
"been",
"closed",
"will",
"lead",
"to",
"exception"
]
| [
"input",
"stream",
"get",
"result",
"as",
"stream",
"(",
")",
";"
]
|
[
"returns",
"the",
"score",
"of",
"the",
"provided",
"item"
]
| [
"int",
"get",
"score",
"(",
"t",
"t",
")",
";"
]
|
[
"get",
"the",
"full",
"assembly",
"text"
]
| [
"public",
"string",
"get",
"text",
"(",
")",
"{",
"if",
"(",
"assembly",
"is",
"visible",
"(",
")",
")",
"{",
"return",
"assembly",
"get",
"text",
"(",
")",
";",
"}",
"return",
"linker",
"get",
"text",
"(",
")",
";",
"}"
]
|
[
"returns",
"the",
"arithmetic",
"mean",
"of",
"{",
"@",
"code",
"x",
"}",
"and",
"{",
"@",
"code",
"y",
"}",
",",
"rounded",
"toward",
"negative",
"infinity",
"this",
"method",
"is",
"resilient",
"to",
"overflow"
]
| [
"public",
"static",
"long",
"mean",
"(",
"long",
"x",
",",
"long",
"y",
")",
"{",
"/",
"/",
"efficient",
"method",
"for",
"computing",
"the",
"arithmetic",
"mean",
"/",
"/",
"the",
"alternative",
"(",
"x",
"+",
"y",
")",
"/",
"2",
"fails",
"for",
"large",
"values",
"/",
"/",
"the",
"alternative",
"(",
"x",
"+",
"y",
")",
">",
">",
">",
"1",
"fails",
"for",
"negative",
"values",
"return",
"(",
"x",
"&",
"y",
")",
"+",
"(",
"(",
"x",
"^",
"y",
")",
">",
">",
"1",
")",
";",
"}"
]
|
[
"test",
"the",
"property",
"'",
"return",
"'"
]
| [
"public",
"void",
"return",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"return",
"}"
]
|
[
"format",
"into",
"the",
"convention",
"used",
"by",
"the",
"indexer",
"'",
"s",
"composite",
"agg",
",",
"so",
"that",
"the",
"normal",
"field",
"name",
"is",
"translated",
"into",
"a",
"rollup",
"fieldname",
"via",
"the",
"agg",
"name"
]
| [
"public",
"static",
"string",
"format",
"indexer",
"agg",
"name",
"(",
"string",
"field",
",",
"string",
"agg",
")",
"{",
"return",
"field",
"+",
"\"",
"\"",
"+",
"agg",
";",
"}"
]
|
[
"gets",
"the",
"ip",
"to",
"state",
"map",
"entry",
"model",
"associated",
"with",
"this",
"func",
"info"
]
| [
"public",
"e",
"h",
"i",
"p",
"to",
"state",
"model",
"get",
"e",
"h",
"i",
"p",
"to",
"state",
"model",
"(",
")",
"{",
"try",
"{",
"check",
"validity",
"(",
")",
";",
"}",
"catch",
"(",
"invalid",
"data",
"type",
"exception",
"e",
")",
"{",
"return",
"null",
";",
"}",
"return",
"ip",
"to",
"state",
"model",
";",
"}"
]
|
[
"this",
"method",
"is",
"called",
"to",
"determine",
"whether",
"manual",
"launching",
"of",
"the",
"agent",
"is",
"allowed",
"at",
"this",
"point",
"in",
"time"
]
| [
"public",
"boolean",
"is",
"manual",
"launch",
"allowed",
"(",
")",
"{",
"return",
"get",
"retention",
"strategy",
"(",
")",
"is",
"manual",
"launch",
"allowed",
"(",
"this",
")",
";",
"}"
]
|
[
"submit",
"a",
"runnable",
"task",
"for",
"execution",
",",
"receiving",
"a",
"future",
"representing",
"that",
"task",
"the",
"future",
"will",
"return",
"a",
"{",
"@",
"code",
"null",
"}",
"result",
"upon",
"completion"
]
| [
"future",
"<",
"?",
">",
"submit",
"(",
"runnable",
"task",
")",
";"
]
|
[
"a",
"template",
"method",
"to",
"post",
"-",
"process",
"a",
"given",
"annotation",
"instance",
"before",
"returning",
"it",
"to",
"the",
"caller",
"the",
"default",
"implementation",
"simply",
"returns",
"the",
"given",
"annotation",
"as",
"-",
"is"
]
| [
"protected",
"<",
"a",
"extends",
"annotation",
">",
"a",
"adapt",
"annotation",
"(",
"a",
"annotation",
")",
"{",
"return",
"annotation",
";",
"}"
]
|
[
"get",
"the",
"effective",
"function",
"to",
"which",
"changes",
"will",
"be",
"made",
"this",
"will",
"be",
"the",
"same",
"as",
"function",
"unless",
"it",
"is",
"a",
"thunk",
"in",
"which",
"case",
"the",
"returned",
"function",
"will",
"be",
"the",
"ultimate",
"non",
"-",
"thunk",
"function"
]
| [
"protected",
"function",
"get",
"affective",
"function",
"(",
"function",
"f",
")",
"{",
"return",
"f",
"is",
"thunk",
"(",
")",
"?",
"f",
"get",
"thunked",
"function",
"(",
"true",
")",
":",
"f",
";",
"}"
]
|
[
"add",
"a",
"new",
"node",
"to",
"the",
"linked",
"list"
]
| [
"final",
"void",
"add",
"last",
"(",
"node",
"n",
")",
"{",
"tail",
"set",
"(",
"n",
")",
";",
"tail",
"=",
"n",
";",
"size",
"+",
"+",
";",
"}"
]
|
[
"returns",
"a",
"{",
"@",
"code",
"map",
"splitter",
"}",
"which",
"splits",
"entries",
"based",
"on",
"this",
"splitter",
",",
"and",
"splits",
"entries",
"into",
"keys",
"and",
"values",
"using",
"the",
"specified",
"separator"
]
| [
"public",
"map",
"splitter",
"with",
"key",
"value",
"separator",
"(",
"char",
"separator",
")",
"{",
"return",
"with",
"key",
"value",
"separator",
"(",
"on",
"(",
"separator",
")",
")",
";",
"}"
]
|
[
"adds",
"the",
"sps",
"path",
"to",
"s",
"p",
"s",
"path",
"ids",
"list"
]
| [
"public",
"void",
"add",
"path",
"id",
"(",
"long",
"id",
")",
"{",
"synchronized",
"(",
"paths",
"to",
"be",
"traveresed",
")",
"{",
"paths",
"to",
"be",
"traveresed",
"add",
"(",
"id",
")",
";",
"}",
"}"
]
|
[
"creates",
"and",
"returns",
"a",
"new",
"dom",
"tree",
"for",
"the",
"specified",
"attribute",
"values",
"for",
"non",
"-",
"configurable",
"attributes",
",",
"this",
"is",
"a",
"single",
"value",
"for",
"configurable",
"attributes",
",",
"this",
"contains",
"one",
"value",
"for",
"each",
"configuration",
"(",
"only",
"toplevel",
"values",
"are",
"named",
"attributes",
";",
"list",
"elements",
"are",
"unnamed",
")",
"in",
"the",
"case",
"of",
"configurable",
"attributes",
",",
"multi",
"-",
"value",
"attributes",
"(",
"e",
"g",
"lists",
")",
"merge",
"all",
"configured",
"lists",
"into",
"an",
"aggregate",
"flattened",
"list",
"single",
"-",
"value",
"attributes",
"simply",
"refrain",
"to",
"set",
"a",
"value",
"and",
"annotate",
"the",
"dom",
"element",
"as",
"configurable",
"<",
"p",
">",
"(",
"the",
"ungainly",
"qualified",
"class",
"name",
"is",
"required",
"to",
"avoid",
"ambiguity",
"with",
"output",
"formatter",
"output",
"type",
")"
]
| [
"private",
"static",
"element",
"create",
"value",
"element",
"(",
"document",
"doc",
",",
"type",
"<",
"?",
">",
"type",
",",
"iterable",
"<",
"object",
">",
"values",
")",
"{",
"/",
"/",
"\"",
"import",
"static",
"\"",
"with",
"method",
"scope",
":",
"type",
"<",
"?",
">",
"fileset",
"entry",
"=",
"build",
"type",
"fileset",
"entry",
";",
"type",
"<",
"?",
">",
"label",
"list",
"=",
"build",
"type",
"label",
"list",
";",
"type",
"<",
"?",
">",
"license",
"=",
"build",
"type",
"license",
";",
"type",
"<",
"?",
">",
"string",
"list",
"=",
"type",
"string",
"list",
";",
"final",
"element",
"elem",
";",
"final",
"boolean",
"has",
"multiple",
"values",
"=",
"iterables",
"size",
"(",
"values",
")",
">",
"1",
";",
"type",
"<",
"?",
">",
"elem",
"type",
"=",
"type",
"get",
"list",
"element",
"type",
"(",
")",
";",
"if",
"(",
"elem",
"type",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"it",
"'",
"s",
"a",
"list",
"(",
"includes",
"\"",
"distribs",
"\"",
")",
"elem",
"=",
"doc",
"create",
"element",
"(",
"\"",
"list",
"\"",
")",
";",
"for",
"(",
"object",
"value",
":",
"values",
")",
"{",
"for",
"(",
"object",
"elem",
"value",
":",
"(",
"collection",
"<",
"?",
">",
")",
"value",
")",
"{",
"elem",
"append",
"child",
"(",
"create",
"value",
"element",
"(",
"doc",
",",
"elem",
"type",
",",
"elem",
"value",
")",
")",
";",
"}",
"}",
"}",
"else",
"if",
"(",
"type",
"instanceof",
"type",
"dict",
"type",
")",
"{",
"set",
"<",
"object",
">",
"visited",
"values",
"=",
"new",
"hash",
"set",
"<",
">",
"(",
")",
";",
"elem",
"=",
"doc",
"create",
"element",
"(",
"\"",
"dict",
"\"",
")",
";",
"type",
"dict",
"type",
"<",
"?",
",",
"?",
">",
"dict",
"type",
"=",
"(",
"type",
"dict",
"type",
"<",
"?",
",",
"?",
">",
")",
"type",
";",
"for",
"(",
"object",
"value",
":",
"values",
")",
"{",
"for",
"(",
"map",
"entry",
"<",
"?",
",",
"?",
">",
"entry",
":",
"(",
"(",
"map",
"<",
"?",
",",
"?",
">",
")",
"value",
")",
"entry",
"set",
"(",
")",
")",
"{",
"if",
"(",
"visited",
"values",
"add",
"(",
"entry",
"get",
"key",
"(",
")",
")",
")",
"{",
"element",
"pair",
"elem",
"=",
"doc",
"create",
"element",
"(",
"\"",
"pair",
"\"",
")",
";",
"elem",
"append",
"child",
"(",
"pair",
"elem",
")",
";",
"pair",
"elem",
"append",
"child",
"(",
"create",
"value",
"element",
"(",
"doc",
",",
"dict",
"type",
"get",
"key",
"type",
"(",
")",
",",
"entry",
"get",
"key",
"(",
")",
")",
")",
";",
"pair",
"elem",
"append",
"child",
"(",
"create",
"value",
"element",
"(",
"doc",
",",
"dict",
"type",
"get",
"value",
"type",
"(",
")",
",",
"entry",
"get",
"value",
"(",
")",
")",
")",
";",
"}",
"}",
"}",
"}",
"else",
"if",
"(",
"type",
"=",
"=",
"license",
")",
"{",
"elem",
"=",
"create",
"single",
"value",
"element",
"(",
"doc",
",",
"\"",
"license",
"\"",
",",
"has",
"multiple",
"values",
")",
";",
"if",
"(",
"!",
"has",
"multiple",
"values",
")",
"{",
"license",
"license",
"=",
"(",
"license",
")",
"iterables",
"get",
"only",
"element",
"(",
"values",
")",
";",
"element",
"exceptions",
"=",
"create",
"value",
"element",
"(",
"doc",
",",
"label",
"list",
",",
"license",
"get",
"exceptions",
"(",
")",
")",
";",
"exceptions",
"set",
"attribute",
"(",
"\"",
"name",
"\"",
",",
"\"",
"exceptions",
"\"",
")",
";",
"elem",
"append",
"child",
"(",
"exceptions",
")",
";",
"element",
"license",
"types",
"=",
"create",
"value",
"element",
"(",
"doc",
",",
"string",
"list",
",",
"license",
"get",
"license",
"types",
"(",
")",
")",
";",
"license",
"types",
"set",
"attribute",
"(",
"\"",
"name",
"\"",
",",
"\"",
"license",
"-",
"types",
"\"",
")",
";",
"elem",
"append",
"child",
"(",
"license",
"types",
")",
";",
"}",
"}",
"else",
"if",
"(",
"type",
"=",
"=",
"fileset",
"entry",
")",
"{",
"/",
"/",
"fileset",
"entries",
":",
"not",
"configurable",
"fileset",
"entry",
"fileset",
"entry",
"=",
"(",
"fileset",
"entry",
")",
"iterables",
"get",
"only",
"element",
"(",
"values",
")",
";",
"elem",
"=",
"doc",
"create",
"element",
"(",
"\"",
"fileset",
"-",
"entry",
"\"",
")",
";",
"elem",
"set",
"attribute",
"(",
"\"",
"srcdir",
"\"",
",",
"fileset",
"entry",
"get",
"src",
"label",
"(",
")",
"to",
"string",
"(",
")",
")",
";",
"elem",
"set",
"attribute",
"(",
"\"",
"destdir",
"\"",
",",
"fileset",
"entry",
"get",
"dest",
"dir",
"(",
")",
"to",
"string",
"(",
")",
")",
";",
"elem",
"set",
"attribute",
"(",
"\"",
"symlinks",
"\"",
",",
"fileset",
"entry",
"get",
"symlink",
"behavior",
"(",
")",
"to",
"string",
"(",
")",
")",
";",
"elem",
"set",
"attribute",
"(",
"\"",
"strip",
"prefix",
"\"",
",",
"fileset",
"entry",
"get",
"strip",
"prefix",
"(",
")",
")",
";",
"if",
"(",
"fileset",
"entry",
"get",
"excludes",
"(",
")",
"!",
"=",
"null",
")",
"{",
"element",
"excludes",
"=",
"create",
"value",
"element",
"(",
"doc",
",",
"label",
"list",
",",
"fileset",
"entry",
"get",
"excludes",
"(",
")",
")",
";",
"excludes",
"set",
"attribute",
"(",
"\"",
"name",
"\"",
",",
"\"",
"excludes",
"\"",
")",
";",
"elem",
"append",
"child",
"(",
"excludes",
")",
";",
"}",
"if",
"(",
"fileset",
"entry",
"get",
"files",
"(",
")",
"!",
"=",
"null",
")",
"{",
"element",
"files",
"=",
"create",
"value",
"element",
"(",
"doc",
",",
"label",
"list",
",",
"fileset",
"entry",
"get",
"files",
"(",
")",
")",
";",
"files",
"set",
"attribute",
"(",
"\"",
"name",
"\"",
",",
"\"",
"files",
"\"",
")",
";",
"elem",
"append",
"child",
"(",
"files",
")",
";",
"}",
"}",
"else",
"{",
"/",
"/",
"integer",
"string",
"label",
"distribution",
"output",
"elem",
"=",
"create",
"single",
"value",
"element",
"(",
"doc",
",",
"type",
"to",
"string",
"(",
")",
",",
"has",
"multiple",
"values",
")",
";",
"if",
"(",
"!",
"has",
"multiple",
"values",
"&",
"&",
"!",
"iterables",
"is",
"empty",
"(",
"values",
")",
")",
"{",
"object",
"value",
"=",
"iterables",
"get",
"only",
"element",
"(",
"values",
")",
";",
"/",
"/",
"values",
"such",
"as",
"those",
"of",
"attribute",
"\"",
"linkstamp",
"\"",
"may",
"be",
"null",
"if",
"(",
"value",
"!",
"=",
"null",
")",
"{",
"try",
"{",
"elem",
"set",
"attribute",
"(",
"\"",
"value",
"\"",
",",
"value",
"to",
"string",
"(",
")",
")",
";",
"}",
"catch",
"(",
"d",
"o",
"m",
"exception",
"e",
")",
"{",
"elem",
"set",
"attribute",
"(",
"\"",
"value",
"\"",
",",
"\"",
"[",
"[",
"[",
"error",
":",
"could",
"not",
"be",
"encoded",
"as",
"xml",
"]",
"]",
"]",
"\"",
")",
";",
"}",
"}",
"}",
"}",
"return",
"elem",
";",
"}"
]
|
[
"is",
"called",
"for",
"each",
"user",
"event",
"triggered",
"of",
"type",
"{",
"@",
"link",
"i",
"}"
]
| [
"protected",
"abstract",
"void",
"event",
"received",
"(",
"channel",
"handler",
"context",
"ctx",
",",
"i",
"evt",
")",
"throws",
"exception",
";"
]
|
[
"returns",
"the",
"procedure",
"name"
]
| [
"public",
"string",
"get",
"name",
"(",
")",
"{",
"return",
"internals",
"get",
"name",
"(",
")",
";",
"}"
]
|
[
"returns",
"the",
"satellite",
"graph",
"viewer",
"this",
"assumes",
"that",
"the",
"mouse",
"event",
"originated",
"from",
"the",
"satellite",
"viewer"
]
| [
"public",
"default",
"satellite",
"graph",
"viewer",
"<",
"v",
",",
"e",
">",
"get",
"satellite",
"graph",
"viewer",
"(",
"mouse",
"event",
"e",
")",
"{",
"visualization",
"viewer",
"<",
"v",
",",
"e",
">",
"viewer",
"=",
"(",
"visualization",
"viewer",
"<",
"v",
",",
"e",
">",
")",
"e",
"get",
"source",
"(",
")",
";",
"/",
"/",
"is",
"this",
"the",
"satellite",
"viewer",
"?",
"if",
"(",
"viewer",
"instanceof",
"satellite",
"graph",
"viewer",
")",
"{",
"return",
"(",
"satellite",
"graph",
"viewer",
"<",
"v",
",",
"e",
">",
")",
"viewer",
";",
"}",
"throw",
"new",
"illegal",
"state",
"exception",
"(",
"\"",
"do",
"not",
"have",
"a",
"satellite",
"graph",
"viewer",
"\"",
")",
";",
"}"
]
|
[
"create",
"a",
"new",
"overlay",
"address",
"space",
"based",
"upon",
"the",
"given",
"overlay",
"block",
"name",
"and",
"base",
"address",
"space"
]
| [
"public",
"address",
"space",
"add",
"overlay",
"space",
"(",
"string",
"block",
"name",
",",
"address",
"space",
"original",
"space",
",",
"long",
"min",
"offset",
",",
"long",
"max",
"offset",
")",
"throws",
"lock",
"exception",
",",
"memory",
"conflict",
"exception",
"{",
"check",
"exclusive",
"access",
"(",
")",
";",
"if",
"(",
"image",
"base",
"override",
")",
"{",
"throw",
"new",
"memory",
"conflict",
"exception",
"(",
"\"",
"overlay",
"spaces",
"may",
"not",
"be",
"created",
"while",
"an",
"image",
"-",
"base",
"override",
"is",
"active",
"\"",
")",
";",
"}",
"overlay",
"address",
"space",
"ov",
"space",
"=",
"null",
";",
"lock",
"acquire",
"(",
")",
";",
"try",
"{",
"ov",
"space",
"=",
"address",
"factory",
"add",
"overlay",
"address",
"space",
"(",
"block",
"name",
",",
"false",
",",
"original",
"space",
",",
"min",
"offset",
",",
"max",
"offset",
")",
";",
"overlay",
"space",
"adapter",
"add",
"overlay",
"space",
"(",
"ov",
"space",
")",
";",
"}",
"catch",
"(",
"i",
"o",
"exception",
"e",
")",
"{",
"db",
"error",
"(",
"e",
")",
";",
"}",
"finally",
"{",
"lock",
"release",
"(",
")",
";",
"}",
"return",
"ov",
"space",
";",
"}"
]
|
[
"return",
"the",
"http",
"status",
"code"
]
| [
"public",
"http",
"status",
"get",
"status",
"code",
"(",
")",
"{",
"return",
"this",
"status",
"code",
";",
"}"
]
|
[
"returns",
"the",
"back",
"end",
"major",
"version",
"number"
]
| [
"public",
"int",
"get",
"back",
"end",
"major",
"version",
"number",
"(",
")",
"{",
"return",
"back",
"end",
"major",
"version",
"number",
";",
"}"
]
|
[
"test",
"the",
"property",
"'",
"name",
"'"
]
| [
"public",
"void",
"name",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"name",
"}"
]
|
[
"perform",
"identity",
"transformation",
"when",
"calling",
"get",
"acl",
"status",
"(",
")",
"if",
"the",
"acl",
"entry",
"type",
"is",
"a",
"user",
"or",
"group",
",",
"and",
"its",
"name",
"is",
"one",
"of",
"the",
"following",
":",
"1",
"$",
"superuser",
":",
"by",
"default",
"it",
"will",
"be",
"transformed",
"to",
"local",
"usergroup",
",",
"this",
"can",
"be",
"disabled",
"by",
"setting",
"\"",
"fs",
"azure",
"identity",
"transformer",
"skip",
"superuser",
"replacement",
"\"",
"to",
"true",
"2",
"user",
"principal",
"id",
":",
"can",
"be",
"transformed",
"to",
"local",
"userlocal",
"group",
",",
"if",
"this",
"principal",
"id",
"matches",
"the",
"principal",
"id",
"set",
"in",
"\"",
"fs",
"azure",
"identity",
"transformer",
"service",
"principal",
"id",
"\"",
"and",
"local",
"identity",
"is",
"stated",
"in",
"\"",
"fs",
"azure",
"identity",
"transformer",
"service",
"principal",
"substitution",
"list",
"\"",
"3",
"user",
"principal",
"name",
"(",
"upn",
")",
":",
"can",
"be",
"transformed",
"to",
"a",
"short",
"name",
"(",
"local",
"identity",
")",
"if",
"original",
"identity",
"is",
"owner",
"name",
",",
"and",
"\"",
"fs",
"azure",
"identity",
"transformer",
"enable",
"short",
"name",
"\"",
"is",
"enabled"
]
| [
"public",
"void",
"transform",
"acl",
"entries",
"for",
"get",
"request",
"(",
"final",
"list",
"<",
"acl",
"entry",
">",
"acl",
"entries",
",",
"string",
"local",
"user",
",",
"string",
"local",
"group",
")",
"throws",
"i",
"o",
"exception",
"{",
"if",
"(",
"skip",
"user",
"identity",
"replacement",
")",
"{",
"return",
";",
"}",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"acl",
"entries",
"size",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"acl",
"entry",
"acl",
"entry",
"=",
"acl",
"entries",
"get",
"(",
"i",
")",
";",
"string",
"name",
"=",
"acl",
"entry",
"get",
"name",
"(",
")",
";",
"string",
"transformed",
"name",
"=",
"name",
";",
"if",
"(",
"name",
"=",
"=",
"null",
"|",
"|",
"name",
"is",
"empty",
"(",
")",
"|",
"|",
"acl",
"entry",
"get",
"type",
"(",
")",
"equals",
"(",
"acl",
"entry",
"type",
"other",
")",
"|",
"|",
"acl",
"entry",
"get",
"type",
"(",
")",
"equals",
"(",
"acl",
"entry",
"type",
"mask",
")",
")",
"{",
"continue",
";",
"}",
"/",
"/",
"when",
"type",
"of",
"acl",
"entry",
"is",
"user",
"or",
"group",
"if",
"(",
"acl",
"entry",
"get",
"type",
"(",
")",
"equals",
"(",
"acl",
"entry",
"type",
"user",
")",
")",
"{",
"transformed",
"name",
"=",
"transform",
"identity",
"for",
"get",
"request",
"(",
"name",
",",
"true",
",",
"local",
"user",
")",
";",
"}",
"else",
"if",
"(",
"acl",
"entry",
"get",
"type",
"(",
")",
"equals",
"(",
"acl",
"entry",
"type",
"group",
")",
")",
"{",
"transformed",
"name",
"=",
"transform",
"identity",
"for",
"get",
"request",
"(",
"name",
",",
"false",
",",
"local",
"group",
")",
";",
"}",
"/",
"/",
"avoid",
"unnecessary",
"new",
"acl",
"entry",
"allocation",
"if",
"(",
"transformed",
"name",
"equals",
"(",
"name",
")",
")",
"{",
"continue",
";",
"}",
"acl",
"entry",
"builder",
"acl",
"entry",
"builder",
"=",
"new",
"acl",
"entry",
"builder",
"(",
")",
";",
"acl",
"entry",
"builder",
"set",
"type",
"(",
"acl",
"entry",
"get",
"type",
"(",
")",
")",
";",
"acl",
"entry",
"builder",
"set",
"name",
"(",
"transformed",
"name",
")",
";",
"acl",
"entry",
"builder",
"set",
"scope",
"(",
"acl",
"entry",
"get",
"scope",
"(",
")",
")",
";",
"acl",
"entry",
"builder",
"set",
"permission",
"(",
"acl",
"entry",
"get",
"permission",
"(",
")",
")",
";",
"/",
"/",
"replace",
"the",
"original",
"acl",
"entry",
"acl",
"entries",
"set",
"(",
"i",
",",
"acl",
"entry",
"builder",
"build",
"(",
")",
")",
";",
"}",
"}"
]
|
[
"perform",
"a",
"lookup",
"on",
"the",
"given",
"method",
"and",
"return",
"associated",
"metadata",
",",
"if",
"any"
]
| [
"t",
"inspect",
"(",
"method",
"method",
")",
";"
]
|
[
"returns",
"the",
"output",
"service",
"to",
"be",
"used",
"it",
"is",
"an",
"error",
"if",
"more",
"than",
"one",
"module",
"returns",
"an",
"output",
"service",
"this",
"method",
"will",
"be",
"called",
"at",
"the",
"beginning",
"of",
"each",
"command",
"(",
"after",
"#",
"before",
"command",
")"
]
| [
"public",
"output",
"service",
"get",
"output",
"service",
"(",
")",
"throws",
"abrupt",
"exit",
"exception",
"{",
"return",
"null",
";",
"}"
]
|
[
"register",
"an",
"sql",
"type",
"for",
"the",
"given",
"parameter"
]
| [
"public",
"void",
"register",
"type",
"name",
"(",
"string",
"param",
"name",
",",
"string",
"type",
"name",
")",
"{",
"assert",
"not",
"null",
"(",
"param",
"name",
",",
"\"",
"parameter",
"name",
"must",
"not",
"be",
"null",
"\"",
")",
";",
"this",
"type",
"names",
"put",
"(",
"param",
"name",
",",
"type",
"name",
")",
";",
"}"
]
|
[
"get",
"pet",
"{",
"pet",
"id",
"}",
":",
"find",
"pet",
"by",
"id",
"returns",
"a",
"single",
"pet"
]
| [
"default",
"completable",
"future",
"<",
"response",
"entity",
"<",
"pet",
">",
">",
"get",
"pet",
"by",
"id",
"(",
"@",
"api",
"param",
"(",
"value",
"=",
"\"",
"id",
"of",
"pet",
"to",
"return",
"\"",
",",
"required",
"=",
"true",
")",
"@",
"path",
"variable",
"(",
"\"",
"pet",
"id",
"\"",
")",
"long",
"pet",
"id",
")",
"{",
"return",
"completable",
"future",
"supply",
"async",
"(",
"(",
")",
"-",
">",
"{",
"get",
"request",
"(",
")",
"if",
"present",
"(",
"request",
"-",
">",
"{",
"for",
"(",
"media",
"type",
"media",
"type",
":",
"media",
"type",
"parse",
"media",
"types",
"(",
"request",
"get",
"header",
"(",
"\"",
"accept",
"\"",
")",
")",
")",
"{",
"if",
"(",
"media",
"type",
"is",
"compatible",
"with",
"(",
"media",
"type",
"value",
"of",
"(",
"\"",
"application",
"/",
"json",
"\"",
")",
")",
")",
"{",
"string",
"example",
"string",
"=",
"\"",
"{",
"\\",
"\"",
"photo",
"urls",
"\\",
"\"",
":",
"[",
"\\",
"\"",
"photo",
"urls",
"\\",
"\"",
",",
"\\",
"\"",
"photo",
"urls",
"\\",
"\"",
"]",
",",
"\\",
"\"",
"name",
"\\",
"\"",
":",
"\\",
"\"",
"doggie",
"\\",
"\"",
",",
"\\",
"\"",
"id",
"\\",
"\"",
":",
"0",
",",
"\\",
"\"",
"category",
"\\",
"\"",
":",
"{",
"\\",
"\"",
"name",
"\\",
"\"",
":",
"\\",
"\"",
"default",
"-",
"name",
"\\",
"\"",
",",
"\\",
"\"",
"id",
"\\",
"\"",
":",
"6",
"}",
",",
"\\",
"\"",
"tags",
"\\",
"\"",
":",
"[",
"{",
"\\",
"\"",
"name",
"\\",
"\"",
":",
"\\",
"\"",
"name",
"\\",
"\"",
",",
"\\",
"\"",
"id",
"\\",
"\"",
":",
"1",
"}",
",",
"{",
"\\",
"\"",
"name",
"\\",
"\"",
":",
"\\",
"\"",
"name",
"\\",
"\"",
",",
"\\",
"\"",
"id",
"\\",
"\"",
":",
"1",
"}",
"]",
",",
"\\",
"\"",
"status",
"\\",
"\"",
":",
"\\",
"\"",
"available",
"\\",
"\"",
"}",
"\"",
";",
"api",
"util",
"set",
"example",
"response",
"(",
"request",
",",
"\"",
"application",
"/",
"json",
"\"",
",",
"example",
"string",
")",
";",
"break",
";",
"}",
"if",
"(",
"media",
"type",
"is",
"compatible",
"with",
"(",
"media",
"type",
"value",
"of",
"(",
"\"",
"application",
"/",
"xml",
"\"",
")",
")",
")",
"{",
"string",
"example",
"string",
"=",
"\"",
"<",
"pet",
">",
"<",
"id",
">",
"123456789",
"<",
"/",
"id",
">",
"<",
"name",
">",
"doggie",
"<",
"/",
"name",
">",
"<",
"photo",
"urls",
">",
"<",
"photo",
"urls",
">",
"aeiou",
"<",
"/",
"photo",
"urls",
">",
"<",
"/",
"photo",
"urls",
">",
"<",
"tags",
">",
"<",
"/",
"tags",
">",
"<",
"status",
">",
"aeiou",
"<",
"/",
"status",
">",
"<",
"/",
"pet",
">",
"\"",
";",
"api",
"util",
"set",
"example",
"response",
"(",
"request",
",",
"\"",
"application",
"/",
"xml",
"\"",
",",
"example",
"string",
")",
";",
"break",
";",
"}",
"}",
"}",
")",
";",
"return",
"new",
"response",
"entity",
"<",
">",
"(",
"http",
"status",
"not",
"implemented",
")",
";",
"}",
",",
"runnable",
":",
":",
"run",
")",
";",
"}"
]
|
[
"move",
"the",
"last",
"cluster",
"to",
"position",
"<",
"code",
">",
"idx",
"<",
"code",
">",
"this",
"is",
"expensive",
"because",
"a",
"merge",
"map",
"of",
"size",
"<",
"code",
">",
"num",
"clusters",
"<",
"code",
">",
"is",
"created",
",",
"so",
"don",
"'",
"t",
"call",
"this",
"method",
"too",
"often",
"todo",
":",
"make",
"this",
"more",
"efficient"
]
| [
"private",
"void",
"move",
"last",
"cluster",
"(",
"int",
"index",
")",
"{",
"if",
"(",
"index",
"!",
"=",
"num",
"clusters",
"-",
"1",
")",
"{",
"/",
"/",
"move",
"the",
"cluster",
"metadata",
"double",
"hold",
"max",
"=",
"cluster",
"maxes",
"get",
"(",
"num",
"clusters",
"-",
"1",
")",
";",
"double",
"hold",
"min",
"=",
"cluster",
"mins",
"get",
"(",
"num",
"clusters",
"-",
"1",
")",
";",
"double",
"hold",
"centroid",
"=",
"cluster",
"centroids",
"get",
"(",
"num",
"clusters",
"-",
"1",
")",
";",
"double",
"hold",
"size",
"=",
"cluster",
"sizes",
"get",
"(",
"num",
"clusters",
"-",
"1",
")",
";",
"for",
"(",
"int",
"i",
"=",
"num",
"clusters",
"-",
"1",
";",
"i",
">",
"index",
";",
"i",
"-",
"-",
")",
"{",
"/",
"/",
"the",
"clusters",
"in",
"range",
"{",
"index",
"num",
"clusters",
"-",
"1",
"}",
"move",
"up",
"1",
"index",
"to",
"make",
"room",
"for",
"the",
"new",
"cluster",
"cluster",
"maxes",
"set",
"(",
"i",
",",
"cluster",
"maxes",
"get",
"(",
"i",
"-",
"1",
")",
")",
";",
"cluster",
"mins",
"set",
"(",
"i",
",",
"cluster",
"mins",
"get",
"(",
"i",
"-",
"1",
")",
")",
";",
"cluster",
"centroids",
"set",
"(",
"i",
",",
"cluster",
"centroids",
"get",
"(",
"i",
"-",
"1",
")",
")",
";",
"cluster",
"sizes",
"set",
"(",
"i",
",",
"cluster",
"sizes",
"get",
"(",
"i",
"-",
"1",
")",
")",
";",
"}",
"cluster",
"maxes",
"set",
"(",
"index",
",",
"hold",
"max",
")",
";",
"cluster",
"mins",
"set",
"(",
"index",
",",
"hold",
"min",
")",
";",
"cluster",
"centroids",
"set",
"(",
"index",
",",
"hold",
"centroid",
")",
";",
"cluster",
"sizes",
"set",
"(",
"index",
",",
"hold",
"size",
")",
";",
"/",
"/",
"move",
"the",
"underlying",
"buckets",
"long",
"unary",
"operator",
"merge",
"map",
"=",
"new",
"long",
"unary",
"operator",
"(",
")",
"{",
"@",
"override",
"public",
"long",
"apply",
"as",
"long",
"(",
"long",
"i",
")",
"{",
"if",
"(",
"i",
"<",
"index",
")",
"{",
"/",
"/",
"the",
"clusters",
"in",
"range",
"{",
"0",
"idx",
"-",
"1",
"}",
"don",
"'",
"t",
"move",
"return",
"i",
";",
"}",
"if",
"(",
"i",
"=",
"=",
"num",
"clusters",
"-",
"1",
")",
"{",
"/",
"/",
"the",
"new",
"cluster",
"moves",
"to",
"index",
"return",
"(",
"long",
")",
"index",
";",
"}",
"/",
"/",
"the",
"clusters",
"in",
"range",
"{",
"index",
"num",
"clusters",
"-",
"1",
"}",
"shift",
"forward",
"return",
"i",
"+",
"1",
";",
"}",
"}",
";",
"rewrite",
"buckets",
"(",
"num",
"clusters",
",",
"merge",
"map",
")",
";",
"if",
"(",
"deferring",
"collector",
"!",
"=",
"null",
")",
"{",
"deferring",
"collector",
"rewrite",
"buckets",
"(",
"merge",
"map",
")",
";",
"}",
"}",
"}"
]
|
[
"true",
"if",
"a",
"dummy",
"http",
"transport",
"should",
"be",
"used",
",",
"or",
"false",
"if",
"the",
"real",
"http",
"transport",
"should",
"be",
"used"
]
| [
"protected",
"boolean",
"add",
"mock",
"http",
"transport",
"(",
")",
"{",
"return",
"true",
";",
"}"
]
|
[
"execute",
"a",
"delete",
"statement",
"the",
"number",
"of",
"rows",
"affected",
"will",
"be",
"returned"
]
| [
"int",
"delete",
"(",
"string",
"statement",
",",
"object",
"parameter",
")",
";"
]
|
[
"set",
"up",
"the",
"{",
"@",
"link",
"container",
"localizer",
"}"
]
| [
"public",
"void",
"build",
"main",
"args",
"(",
"list",
"<",
"string",
">",
"command",
",",
"string",
"user",
",",
"string",
"app",
"id",
",",
"string",
"loc",
"id",
",",
"inet",
"socket",
"address",
"nm",
"addr",
",",
"string",
"token",
"file",
"name",
",",
"list",
"<",
"string",
">",
"local",
"dirs",
")",
"{",
"container",
"localizer",
"build",
"main",
"args",
"(",
"command",
",",
"user",
",",
"app",
"id",
",",
"loc",
"id",
",",
"nm",
"addr",
",",
"token",
"file",
"name",
",",
"local",
"dirs",
",",
"super",
"get",
"conf",
"(",
")",
")",
";",
"}"
]
|
[
"returns",
"the",
"file",
"size",
"in",
"bytes"
]
| [
"public",
"long",
"length",
"(",
")",
"throws",
"i",
"o",
"exception",
",",
"interrupted",
"exception",
"{",
"return",
"act",
"(",
"new",
"length",
"(",
")",
")",
";",
"}"
]
|
[
"get",
"the",
"actual",
"instance",
",",
"which",
"can",
"be",
"the",
"following",
":",
"basque",
"pig",
",",
"danish",
"pig"
]
| [
"public",
"object",
"get",
"actual",
"instance",
"(",
")",
"{",
"return",
"super",
"get",
"actual",
"instance",
"(",
")",
";",
"}"
]
|
[
"return",
"the",
"connection",
"id",
"of",
"the",
"given",
"object",
"if",
"the",
"provided",
"object",
"is",
"in",
"fact",
"a",
"protocol",
"translator",
",",
"we",
"'",
"ll",
"get",
"the",
"connection",
"id",
"of",
"the",
"underlying",
"proxy",
"object"
]
| [
"public",
"static",
"connection",
"id",
"get",
"connection",
"id",
"for",
"proxy",
"(",
"object",
"proxy",
")",
"{",
"if",
"(",
"proxy",
"instanceof",
"protocol",
"translator",
")",
"{",
"proxy",
"=",
"(",
"(",
"protocol",
"translator",
")",
"proxy",
")",
"get",
"underlying",
"proxy",
"object",
"(",
")",
";",
"}",
"rpc",
"invocation",
"handler",
"inv",
"=",
"(",
"rpc",
"invocation",
"handler",
")",
"proxy",
"get",
"invocation",
"handler",
"(",
"proxy",
")",
";",
"return",
"inv",
"get",
"connection",
"id",
"(",
")",
";",
"}"
]
|
[
"execute",
"the",
"command"
]
| [
"public",
"static",
"command",
"result",
"exec",
"cmd",
"(",
"final",
"string",
"command",
",",
"final",
"boolean",
"is",
"rooted",
")",
"{",
"return",
"exec",
"cmd",
"(",
"new",
"string",
"[",
"]",
"{",
"command",
"}",
",",
"is",
"rooted",
",",
"true",
")",
";",
"}"
]
|
[
"place",
"an",
"order",
"for",
"a",
"pet",
"<",
"b",
">",
"200",
"<",
"b",
">",
"-",
"successful",
"operation",
"<",
"b",
">",
"400",
"<",
"b",
">",
"-",
"invalid",
"order"
]
| [
"public",
"response",
"entity",
"<",
"order",
">",
"place",
"order",
"with",
"http",
"info",
"(",
"order",
"body",
")",
"throws",
"rest",
"client",
"exception",
"{",
"object",
"post",
"body",
"=",
"body",
";",
"/",
"/",
"verify",
"the",
"required",
"parameter",
"'",
"body",
"'",
"is",
"set",
"if",
"(",
"body",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"http",
"client",
"error",
"exception",
"(",
"http",
"status",
"bad",
"request",
",",
"\"",
"missing",
"the",
"required",
"parameter",
"'",
"body",
"'",
"when",
"calling",
"place",
"order",
"\"",
")",
";",
"}",
"string",
"path",
"=",
"api",
"client",
"expand",
"path",
"(",
"\"",
"/",
"store",
"/",
"order",
"\"",
",",
"collections",
"<",
"string",
",",
"object",
">",
"empty",
"map",
"(",
")",
")",
";",
"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",
"=",
"{",
"\"",
"application",
"/",
"xml",
"\"",
",",
"\"",
"application",
"/",
"json",
"\"",
"}",
";",
"final",
"list",
"<",
"media",
"type",
">",
"local",
"var",
"accept",
"=",
"api",
"client",
"select",
"header",
"accept",
"(",
"local",
"var",
"accepts",
")",
";",
"final",
"string",
"[",
"]",
"content",
"types",
"=",
"{",
"}",
";",
"final",
"media",
"type",
"content",
"type",
"=",
"api",
"client",
"select",
"header",
"content",
"type",
"(",
"content",
"types",
")",
";",
"string",
"[",
"]",
"auth",
"names",
"=",
"new",
"string",
"[",
"]",
"{",
"}",
";",
"parameterized",
"type",
"reference",
"<",
"order",
">",
"return",
"type",
"=",
"new",
"parameterized",
"type",
"reference",
"<",
"order",
">",
"(",
")",
"{",
"}",
";",
"return",
"api",
"client",
"invoke",
"a",
"p",
"i",
"(",
"path",
",",
"http",
"method",
"post",
",",
"query",
"params",
",",
"post",
"body",
",",
"header",
"params",
",",
"cookie",
"params",
",",
"form",
"params",
",",
"local",
"var",
"accept",
",",
"content",
"type",
",",
"auth",
"names",
",",
"return",
"type",
")",
";",
"}"
]
|
[
"revokes",
"the",
"specified",
"privilege",
"on",
"the",
"specified",
"table",
"from",
"the",
"specified",
"user"
]
| [
"default",
"void",
"revoke",
"table",
"privileges",
"(",
"connector",
"session",
"session",
",",
"schema",
"table",
"name",
"table",
"name",
",",
"set",
"<",
"privilege",
">",
"privileges",
",",
"presto",
"principal",
"grantee",
",",
"boolean",
"grant",
"option",
")",
"{",
"throw",
"new",
"presto",
"exception",
"(",
"not",
"supported",
",",
"\"",
"this",
"connector",
"does",
"not",
"support",
"revokes",
"\"",
")",
";",
"}"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.