docstring_tokens
list | code_tokens
list |
|---|---|
[
"creates",
"a",
"new",
"listenable",
"future",
"-",
"style",
"stub",
"that",
"supports",
"unary",
"calls",
"on",
"the",
"service"
] |
[
"public",
"static",
"secret",
"discovery",
"service",
"future",
"stub",
"new",
"future",
"stub",
"(",
"io",
"grpc",
"channel",
"channel",
")",
"{",
"io",
"grpc",
"stub",
"abstract",
"stub",
"stub",
"factory",
"<",
"secret",
"discovery",
"service",
"future",
"stub",
">",
"factory",
"=",
"new",
"io",
"grpc",
"stub",
"abstract",
"stub",
"stub",
"factory",
"<",
"secret",
"discovery",
"service",
"future",
"stub",
">",
"(",
")",
"{",
"@",
"java",
"lang",
"override",
"public",
"secret",
"discovery",
"service",
"future",
"stub",
"new",
"stub",
"(",
"io",
"grpc",
"channel",
"channel",
",",
"io",
"grpc",
"call",
"options",
"call",
"options",
")",
"{",
"return",
"new",
"secret",
"discovery",
"service",
"future",
"stub",
"(",
"channel",
",",
"call",
"options",
")",
";",
"}",
"}",
";",
"return",
"secret",
"discovery",
"service",
"future",
"stub",
"new",
"stub",
"(",
"factory",
",",
"channel",
")",
";",
"}"
] |
[
"reads",
"the",
"existing",
"extended",
"acl",
"entries",
"of",
"an",
"i",
"node",
"attribute",
"object"
] |
[
"public",
"static",
"list",
"<",
"acl",
"entry",
">",
"read",
"i",
"node",
"acl",
"(",
"i",
"node",
"attributes",
"inode",
"attr",
")",
"{",
"acl",
"feature",
"f",
"=",
"inode",
"attr",
"get",
"acl",
"feature",
"(",
")",
";",
"return",
"get",
"entries",
"from",
"acl",
"feature",
"(",
"f",
")",
";",
"}"
] |
[
"close",
"the",
"underlying",
"connection",
"the",
"provider",
"of",
"this",
"data",
"source",
"needs",
"to",
"care",
"for",
"proper",
"shutdown",
"as",
"this",
"bean",
"implements",
"disposable",
"bean",
",",
"a",
"bean",
"factory",
"will",
"automatically",
"invoke",
"this",
"on",
"destruction",
"of",
"its",
"cached",
"singletons"
] |
[
"public",
"void",
"destroy",
"(",
")",
"{",
"synchronized",
"(",
"this",
"connection",
"monitor",
")",
"{",
"close",
"connection",
"(",
")",
";",
"}",
"}"
] |
[
"return",
"the",
"list",
"of",
"environment",
"variable",
"names",
"specified",
"in",
"the",
"given",
"property",
"or",
"default",
"string",
"and",
"those",
"specified",
"individually",
"with",
"the",
"propname",
"varname",
"syntax",
"(",
"e",
"g",
",",
"mapreduce",
"map",
"env",
"varname",
"=",
"value",
")"
] |
[
"public",
"static",
"set",
"<",
"string",
">",
"get",
"env",
"vars",
"from",
"input",
"property",
"(",
"string",
"prop",
"name",
",",
"string",
"default",
"prop",
"value",
",",
"configuration",
"conf",
")",
"{",
"string",
"env",
"string",
"=",
"conf",
"get",
"(",
"prop",
"name",
",",
"default",
"prop",
"value",
")",
";",
"set",
"<",
"string",
">",
"var",
"set",
"=",
"get",
"env",
"vars",
"from",
"input",
"string",
"(",
"env",
"string",
")",
";",
"map",
"<",
"string",
",",
"string",
">",
"prop",
"map",
"=",
"conf",
"get",
"props",
"with",
"prefix",
"(",
"prop",
"name",
"+",
"\"",
"\"",
")",
";",
"var",
"set",
"add",
"all",
"(",
"prop",
"map",
"key",
"set",
"(",
")",
")",
";",
"return",
"var",
"set",
";",
"}"
] |
[
"returns",
"just",
"the",
"file",
"name",
"portion",
",",
"without",
"the",
"path"
] |
[
"public",
"string",
"get",
"file",
"name",
"(",
")",
"{",
"return",
"name",
";",
"}"
] |
[
"get",
"attribute",
"integer"
] |
[
"public",
"integer",
"get",
"attribute",
"integer",
"(",
")",
"{",
"return",
"attribute",
"integer",
";",
"}"
] |
[
"gets",
"the",
"comment",
"from",
"the",
"given",
"{",
"@",
"link",
"doc",
"comment",
"tree",
"}"
] |
[
"private",
"string",
"get",
"comment",
"(",
"doc",
"comment",
"tree",
"doc",
"comment",
"tree",
")",
"{",
"if",
"(",
"doc",
"comment",
"tree",
"!",
"=",
"null",
")",
"{",
"return",
"get",
"comment",
"(",
"doc",
"comment",
"tree",
"get",
"full",
"body",
"(",
")",
")",
";",
"}",
"return",
"\"",
"\"",
";",
"}"
] |
[
"sets",
"the",
"toggle",
"state",
"for",
"this",
"action"
] |
[
"public",
"abstract",
"void",
"set",
"selected",
"(",
"boolean",
"new",
"value",
")",
";"
] |
[
"gets",
"the",
"component",
"display",
"field",
"offsets"
] |
[
"int",
"[",
"]",
"get",
"field",
"offsets",
"(",
")",
"{",
"return",
"column",
"offsets",
";",
"}"
] |
[
"test",
"request",
"scoped",
"caching",
"doesn",
"'",
"t",
"prevent",
"different",
"ones",
"from",
"executing"
] |
[
"public",
"void",
"test",
"request",
"cache",
"2",
"using",
"thread",
"isolation",
"(",
")",
"{",
"test",
"circuit",
"breaker",
"circuit",
"breaker",
"=",
"new",
"test",
"circuit",
"breaker",
"(",
")",
";",
"successful",
"cacheable",
"command",
"<",
"string",
">",
"command",
"1",
"=",
"new",
"successful",
"cacheable",
"command",
"<",
"string",
">",
"(",
"circuit",
"breaker",
",",
"true",
",",
"\"",
"a",
"\"",
")",
";",
"successful",
"cacheable",
"command",
"<",
"string",
">",
"command",
"2",
"=",
"new",
"successful",
"cacheable",
"command",
"<",
"string",
">",
"(",
"circuit",
"breaker",
",",
"true",
",",
"\"",
"b",
"\"",
")",
";",
"assert",
"true",
"(",
"command",
"1",
"is",
"command",
"running",
"in",
"thread",
"(",
")",
")",
";",
"future",
"<",
"string",
">",
"f",
"1",
"=",
"command",
"1",
"observe",
"(",
")",
"to",
"blocking",
"(",
")",
"to",
"future",
"(",
")",
";",
"future",
"<",
"string",
">",
"f",
"2",
"=",
"command",
"2",
"observe",
"(",
")",
"to",
"blocking",
"(",
")",
"to",
"future",
"(",
")",
";",
"try",
"{",
"assert",
"equals",
"(",
"\"",
"a",
"\"",
",",
"f",
"1",
"get",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"\"",
"b",
"\"",
",",
"f",
"2",
"get",
"(",
")",
")",
";",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"throw",
"new",
"runtime",
"exception",
"(",
"e",
")",
";",
"}",
"assert",
"true",
"(",
"command",
"1",
"executed",
")",
";",
"/",
"/",
"both",
"should",
"execute",
"as",
"they",
"are",
"different",
"assert",
"true",
"(",
"command",
"2",
"executed",
")",
";",
"assert",
"command",
"execution",
"events",
"(",
"command",
"1",
",",
"hystrix",
"event",
"type",
"emit",
",",
"hystrix",
"event",
"type",
"success",
")",
";",
"assert",
"command",
"execution",
"events",
"(",
"command",
"2",
",",
"hystrix",
"event",
"type",
"emit",
",",
"hystrix",
"event",
"type",
"success",
")",
";",
"assert",
"true",
"(",
"command",
"2",
"get",
"execution",
"time",
"in",
"milliseconds",
"(",
")",
">",
"-",
"1",
")",
";",
"assert",
"false",
"(",
"command",
"2",
"is",
"response",
"from",
"cache",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"0",
",",
"circuit",
"breaker",
"metrics",
"get",
"current",
"concurrent",
"execution",
"count",
"(",
")",
")",
";",
"assert",
"sane",
"hystrix",
"request",
"log",
"(",
"2",
")",
";",
"}"
] |
[
"parses",
"a",
"{",
"@",
"code",
"runtime",
"visible",
"annotations",
"}",
"attribute"
] |
[
"private",
"attribute",
"runtime",
"visible",
"annotations",
"(",
"direct",
"class",
"file",
"cf",
",",
"int",
"offset",
",",
"int",
"length",
",",
"parse",
"observer",
"observer",
")",
"{",
"if",
"(",
"length",
"<",
"2",
")",
"{",
"throw",
"severely",
"truncated",
"(",
")",
";",
"}",
"annotation",
"parser",
"ap",
"=",
"new",
"annotation",
"parser",
"(",
"cf",
",",
"offset",
",",
"length",
",",
"observer",
")",
";",
"annotations",
"annotations",
"=",
"ap",
"parse",
"annotation",
"attribute",
"(",
"annotation",
"visibility",
"runtime",
")",
";",
"return",
"new",
"att",
"runtime",
"visible",
"annotations",
"(",
"annotations",
",",
"length",
")",
";",
"}"
] |
[
"if",
"tinker",
"is",
"load",
",",
"and",
"it",
"crash",
"more",
"than",
"max",
"crash",
"count",
",",
"then",
"we",
"just",
"clean",
"patch"
] |
[
"private",
"boolean",
"tinker",
"fast",
"crash",
"protect",
"(",
")",
"{",
"application",
"like",
"application",
"like",
"=",
"tinker",
"manager",
"get",
"tinker",
"application",
"like",
"(",
")",
";",
"if",
"(",
"application",
"like",
"=",
"=",
"null",
"|",
"|",
"application",
"like",
"get",
"application",
"(",
")",
"=",
"=",
"null",
")",
"{",
"return",
"false",
";",
"}",
"if",
"(",
"!",
"tinker",
"application",
"helper",
"is",
"tinker",
"load",
"success",
"(",
"application",
"like",
")",
")",
"{",
"return",
"false",
";",
"}",
"final",
"long",
"elapsed",
"time",
"=",
"system",
"clock",
"elapsed",
"realtime",
"(",
")",
"-",
"application",
"like",
"get",
"application",
"start",
"elapsed",
"time",
"(",
")",
";",
"/",
"/",
"this",
"process",
"may",
"not",
"install",
"tinker",
",",
"so",
"we",
"use",
"tinker",
"application",
"helper",
"api",
"if",
"(",
"elapsed",
"time",
"<",
"quick",
"crash",
"elapse",
")",
"{",
"string",
"current",
"version",
"=",
"tinker",
"application",
"helper",
"get",
"current",
"version",
"(",
"application",
"like",
")",
";",
"if",
"(",
"share",
"tinker",
"internals",
"is",
"null",
"or",
"nil",
"(",
"current",
"version",
")",
")",
"{",
"return",
"false",
";",
"}",
"shared",
"preferences",
"sp",
"=",
"application",
"like",
"get",
"application",
"(",
")",
"get",
"shared",
"preferences",
"(",
"share",
"constants",
"tinker",
"share",
"preference",
"config",
",",
"context",
"mode",
"multi",
"process",
")",
";",
"int",
"fast",
"crash",
"count",
"=",
"sp",
"get",
"int",
"(",
"current",
"version",
",",
"0",
")",
"+",
"1",
";",
"if",
"(",
"fast",
"crash",
"count",
">",
"=",
"max",
"crash",
"count",
")",
"{",
"sample",
"tinker",
"report",
"on",
"fast",
"crash",
"protect",
"(",
")",
";",
"tinker",
"application",
"helper",
"clean",
"patch",
"(",
"application",
"like",
")",
";",
"tinker",
"log",
"e",
"(",
"tag",
",",
"\"",
"tinker",
"has",
"fast",
"crash",
"more",
"than",
"%",
"d",
",",
"we",
"just",
"clean",
"patch",
"!",
"\"",
",",
"fast",
"crash",
"count",
")",
";",
"return",
"true",
";",
"}",
"else",
"{",
"sp",
"edit",
"(",
")",
"put",
"int",
"(",
"current",
"version",
",",
"fast",
"crash",
"count",
")",
"commit",
"(",
")",
";",
"tinker",
"log",
"e",
"(",
"tag",
",",
"\"",
"tinker",
"has",
"fast",
"crash",
"%",
"d",
"times",
"\"",
",",
"fast",
"crash",
"count",
")",
";",
"}",
"}",
"return",
"false",
";",
"}"
] |
[
"returns",
"an",
"index",
"for",
"which",
"{",
"@",
"link",
"#",
"value",
"at",
"}",
"would",
"return",
"the",
"specified",
"key",
",",
"or",
"a",
"negative",
"number",
"if",
"no",
"keys",
"map",
"to",
"the",
"specified",
"value",
"beware",
"that",
"this",
"is",
"a",
"linear",
"search",
",",
"unlike",
"lookups",
"by",
"key",
",",
"and",
"that",
"multiple",
"keys",
"can",
"map",
"to",
"the",
"same",
"value",
"and",
"this",
"will",
"find",
"only",
"one",
"of",
"them",
"note",
"also",
"that",
"unlike",
"most",
"collections",
"'",
"{",
"@",
"code",
"index",
"of",
"}",
"methods",
",",
"this",
"method",
"compares",
"values",
"using",
"{",
"@",
"code",
"=",
"=",
"}",
"rather",
"than",
"{",
"@",
"code",
"equals",
"}"
] |
[
"public",
"int",
"index",
"of",
"value",
"(",
"e",
"value",
")",
"{",
"if",
"(",
"m",
"garbage",
")",
"{",
"gc",
"(",
")",
";",
"}",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"m",
"size",
";",
"i",
"+",
"+",
")",
"if",
"(",
"m",
"values",
"[",
"i",
"]",
"=",
"=",
"value",
")",
"return",
"i",
";",
"return",
"-",
"1",
";",
"}"
] |
[
"this",
"reads",
"all",
"watches",
"from",
"the",
"watches",
"indexalias",
"and",
"puts",
"them",
"into",
"memory",
"for",
"a",
"short",
"period",
"of",
"time",
",",
"before",
"they",
"are",
"fed",
"into",
"the",
"trigger",
"service"
] |
[
"private",
"collection",
"<",
"watch",
">",
"load",
"watches",
"(",
"cluster",
"state",
"cluster",
"state",
")",
"{",
"index",
"metadata",
"index",
"metadata",
"=",
"watch",
"store",
"utils",
"get",
"concrete",
"index",
"(",
"index",
",",
"cluster",
"state",
"metadata",
"(",
")",
")",
";",
"/",
"/",
"no",
"index",
"exists",
",",
"all",
"good",
",",
"we",
"can",
"start",
"if",
"(",
"index",
"metadata",
"=",
"=",
"null",
")",
"{",
"return",
"collections",
"empty",
"list",
"(",
")",
";",
"}",
"search",
"response",
"response",
"=",
"null",
";",
"list",
"<",
"watch",
">",
"watches",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"try",
"{",
"refresh",
"response",
"refresh",
"response",
"=",
"client",
"admin",
"(",
")",
"indices",
"(",
")",
"refresh",
"(",
"new",
"refresh",
"request",
"(",
"index",
")",
")",
"action",
"get",
"(",
"time",
"value",
"time",
"value",
"seconds",
"(",
"5",
")",
")",
";",
"if",
"(",
"refresh",
"response",
"get",
"successful",
"shards",
"(",
")",
"<",
"index",
"metadata",
"get",
"number",
"of",
"shards",
"(",
")",
")",
"{",
"throw",
"illegal",
"state",
"(",
"\"",
"not",
"all",
"required",
"shards",
"have",
"been",
"refreshed",
"\"",
")",
";",
"}",
"/",
"/",
"find",
"out",
"local",
"shards",
"string",
"watch",
"index",
"name",
"=",
"index",
"metadata",
"get",
"index",
"(",
")",
"get",
"name",
"(",
")",
";",
"routing",
"node",
"routing",
"node",
"=",
"cluster",
"state",
"get",
"routing",
"nodes",
"(",
")",
"node",
"(",
"cluster",
"state",
"nodes",
"(",
")",
"get",
"local",
"node",
"id",
"(",
")",
")",
";",
"/",
"/",
"yes",
",",
"this",
"can",
"happen",
",",
"if",
"the",
"state",
"is",
"not",
"recovered",
"if",
"(",
"routing",
"node",
"=",
"=",
"null",
")",
"{",
"return",
"collections",
"empty",
"list",
"(",
")",
";",
"}",
"list",
"<",
"shard",
"routing",
">",
"local",
"shards",
"=",
"routing",
"node",
"shards",
"with",
"state",
"(",
"watch",
"index",
"name",
",",
"relocating",
",",
"started",
")",
";",
"/",
"/",
"find",
"out",
"all",
"allocation",
"ids",
"list",
"<",
"shard",
"routing",
">",
"watch",
"index",
"shard",
"routings",
"=",
"cluster",
"state",
"get",
"routing",
"table",
"(",
")",
"all",
"shards",
"(",
"watch",
"index",
"name",
")",
";",
"search",
"request",
"search",
"request",
"=",
"new",
"search",
"request",
"(",
"index",
")",
"scroll",
"(",
"scroll",
"timeout",
")",
"preference",
"(",
"preference",
"only",
"local",
"to",
"string",
"(",
")",
")",
"source",
"(",
"new",
"search",
"source",
"builder",
"(",
")",
"size",
"(",
"scroll",
"size",
")",
"sort",
"(",
"sort",
"builders",
"field",
"sort",
"(",
"\"",
"doc",
"\"",
")",
")",
"seq",
"no",
"and",
"primary",
"term",
"(",
"true",
")",
")",
";",
"response",
"=",
"client",
"search",
"(",
"search",
"request",
")",
"action",
"get",
"(",
"default",
"search",
"timeout",
")",
";",
"if",
"(",
"response",
"get",
"total",
"shards",
"(",
")",
"!",
"=",
"response",
"get",
"successful",
"shards",
"(",
")",
")",
"{",
"throw",
"new",
"elasticsearch",
"exception",
"(",
"\"",
"partial",
"response",
"while",
"loading",
"watches",
"\"",
")",
";",
"}",
"if",
"(",
"response",
"get",
"hits",
"(",
")",
"get",
"total",
"hits",
"(",
")",
"value",
"=",
"=",
"0",
")",
"{",
"return",
"collections",
"empty",
"list",
"(",
")",
";",
"}",
"map",
"<",
"integer",
",",
"list",
"<",
"string",
">",
">",
"sorted",
"shards",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
"local",
"shards",
"size",
"(",
")",
")",
";",
"for",
"(",
"shard",
"routing",
"local",
"shard",
"routing",
":",
"local",
"shards",
")",
"{",
"list",
"<",
"string",
">",
"sorted",
"allocation",
"ids",
"=",
"watch",
"index",
"shard",
"routings",
"stream",
"(",
")",
"filter",
"(",
"sr",
"-",
">",
"local",
"shard",
"routing",
"get",
"id",
"(",
")",
"=",
"=",
"sr",
"get",
"id",
"(",
")",
")",
"map",
"(",
"shard",
"routing",
":",
":",
"allocation",
"id",
")",
"filter",
"(",
"objects",
":",
":",
"non",
"null",
")",
"map",
"(",
"allocation",
"id",
":",
":",
"get",
"id",
")",
"filter",
"(",
"objects",
":",
":",
"non",
"null",
")",
"sorted",
"(",
")",
"collect",
"(",
"collectors",
"to",
"list",
"(",
")",
")",
";",
"sorted",
"shards",
"put",
"(",
"local",
"shard",
"routing",
"get",
"id",
"(",
")",
",",
"sorted",
"allocation",
"ids",
")",
";",
"}",
"while",
"(",
"response",
"get",
"hits",
"(",
")",
"get",
"hits",
"(",
")",
"length",
"!",
"=",
"0",
")",
"{",
"for",
"(",
"search",
"hit",
"hit",
":",
"response",
"get",
"hits",
"(",
")",
")",
"{",
"/",
"/",
"find",
"out",
"if",
"this",
"hit",
"should",
"be",
"processed",
"locally",
"optional",
"<",
"shard",
"routing",
">",
"corresponding",
"shard",
"optional",
"=",
"local",
"shards",
"stream",
"(",
")",
"filter",
"(",
"sr",
"-",
">",
"sr",
"shard",
"id",
"(",
")",
"equals",
"(",
"hit",
"get",
"shard",
"(",
")",
"get",
"shard",
"id",
"(",
")",
")",
")",
"find",
"first",
"(",
")",
";",
"if",
"(",
"corresponding",
"shard",
"optional",
"is",
"present",
"(",
")",
"=",
"=",
"false",
")",
"{",
"continue",
";",
"}",
"shard",
"routing",
"corresponding",
"shard",
"=",
"corresponding",
"shard",
"optional",
"get",
"(",
")",
";",
"list",
"<",
"string",
">",
"shard",
"allocation",
"ids",
"=",
"sorted",
"shards",
"get",
"(",
"hit",
"get",
"shard",
"(",
")",
"get",
"shard",
"id",
"(",
")",
"id",
"(",
")",
")",
";",
"/",
"/",
"based",
"on",
"the",
"shard",
"allocation",
"ids",
",",
"get",
"the",
"bucket",
"of",
"the",
"shard",
",",
"this",
"hit",
"was",
"in",
"int",
"bucket",
"=",
"shard",
"allocation",
"ids",
"index",
"of",
"(",
"corresponding",
"shard",
"allocation",
"id",
"(",
")",
"get",
"id",
"(",
")",
")",
";",
"string",
"id",
"=",
"hit",
"get",
"id",
"(",
")",
";",
"if",
"(",
"parse",
"watch",
"on",
"this",
"node",
"(",
"hit",
"get",
"id",
"(",
")",
",",
"shard",
"allocation",
"ids",
"size",
"(",
")",
",",
"bucket",
")",
"=",
"=",
"false",
")",
"{",
"continue",
";",
"}",
"try",
"{",
"watch",
"watch",
"=",
"parser",
"parse",
"(",
"id",
",",
"true",
",",
"hit",
"get",
"source",
"ref",
"(",
")",
",",
"x",
"content",
"type",
"json",
",",
"hit",
"get",
"seq",
"no",
"(",
")",
",",
"hit",
"get",
"primary",
"term",
"(",
")",
")",
";",
"if",
"(",
"watch",
"status",
"(",
")",
"state",
"(",
")",
"is",
"active",
"(",
")",
")",
"{",
"watches",
"add",
"(",
"watch",
")",
";",
"}",
"}",
"catch",
"(",
"exception",
"e",
")",
"{",
"logger",
"error",
"(",
"(",
"org",
"apache",
"logging",
"log",
"4j",
"util",
"supplier",
"<",
"?",
">",
")",
"(",
")",
"-",
">",
"new",
"parameterized",
"message",
"(",
"\"",
"couldn",
"'",
"t",
"load",
"watch",
"[",
"{",
"}",
"]",
",",
"ignoring",
"it",
"\"",
",",
"id",
")",
",",
"e",
")",
";",
"}",
"}",
"search",
"scroll",
"request",
"request",
"=",
"new",
"search",
"scroll",
"request",
"(",
"response",
"get",
"scroll",
"id",
"(",
")",
")",
";",
"request",
"scroll",
"(",
"scroll",
"timeout",
")",
";",
"response",
"=",
"client",
"search",
"scroll",
"(",
"request",
")",
"action",
"get",
"(",
"default",
"search",
"timeout",
")",
";",
"}",
"}",
"finally",
"{",
"if",
"(",
"response",
"!",
"=",
"null",
")",
"{",
"clear",
"scroll",
"request",
"clear",
"scroll",
"request",
"=",
"new",
"clear",
"scroll",
"request",
"(",
")",
";",
"clear",
"scroll",
"request",
"add",
"scroll",
"id",
"(",
"response",
"get",
"scroll",
"id",
"(",
")",
")",
";",
"client",
"clear",
"scroll",
"(",
"clear",
"scroll",
"request",
")",
"action",
"get",
"(",
"scroll",
"timeout",
")",
";",
"}",
"}",
"logger",
"debug",
"(",
"\"",
"loaded",
"[",
"{",
"}",
"]",
"watches",
"for",
"execution",
"\"",
",",
"watches",
"size",
"(",
")",
")",
";",
"return",
"watches",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"1",
"2",
"3number",
"'"
] |
[
"public",
"void",
"1",
"2",
"3number",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"1",
"2",
"3number",
"}"
] |
[
"set",
"the",
"name",
"of",
"this",
"transaction",
"default",
"is",
"none",
"this",
"will",
"be",
"used",
"as",
"transaction",
"name",
"to",
"be",
"shown",
"in",
"a",
"transaction",
"monitor",
",",
"if",
"applicable",
"(",
"for",
"example",
",",
"web",
"logic",
"'",
"s",
")"
] |
[
"public",
"final",
"void",
"set",
"name",
"(",
"string",
"name",
")",
"{",
"this",
"name",
"=",
"name",
";",
"}"
] |
[
"resets",
"this",
"property",
"to",
"its",
"default",
"value",
"on",
"this",
"mount",
"content"
] |
[
"void",
"reset",
"(",
"object",
"mount",
"content",
")",
";"
] |
[
"parses",
"this",
"central",
"directory",
",",
"and",
"maps",
"the",
"contained",
"entries",
"with",
"{",
"@",
"link",
"directory",
"entry",
"}",
"s"
] |
[
"public",
"central",
"directory",
"parse",
"(",
")",
"throws",
"illegal",
"state",
"exception",
"{",
"preconditions",
"check",
"state",
"(",
"file",
"offset",
"!",
"=",
"-",
"1",
",",
"\"",
"file",
"offset",
"not",
"set",
"prior",
"to",
"parsing",
"\"",
")",
";",
"count",
"=",
"0",
";",
"clear",
"maps",
"(",
")",
";",
"int",
"rel",
"pos",
"=",
"0",
";",
"buffer",
"position",
"(",
"0",
")",
";",
"while",
"(",
"buffer",
"has",
"remaining",
"(",
")",
"&",
"&",
"buffer",
"get",
"int",
"(",
"buffer",
"position",
"(",
")",
")",
"=",
"=",
"directory",
"entry",
"signature",
")",
"{",
"count",
"+",
"+",
";",
"directory",
"entry",
"entry",
"=",
"directory",
"entry",
"view",
"of",
"(",
"buffer",
")",
"at",
"(",
"file",
"offset",
"+",
"rel",
"pos",
")",
";",
"entries",
"add",
"(",
"entry",
")",
";",
"rel",
"pos",
"+",
"=",
"entry",
"get",
"size",
"(",
")",
";",
"buffer",
"position",
"(",
"rel",
"pos",
")",
";",
"}",
"return",
"this",
";",
"}"
] |
[
"calculate",
"the",
"md5",
"digest",
"of",
"the",
"given",
"bytes"
] |
[
"public",
"static",
"byte",
"[",
"]",
"md",
"5",
"digest",
"(",
"byte",
"[",
"]",
"bytes",
")",
"{",
"return",
"digest",
"(",
"md5",
"algorithm",
"name",
",",
"bytes",
")",
";",
"}"
] |
[
"creates",
"a",
"new",
"blocking",
"-",
"style",
"stub",
"that",
"supports",
"unary",
"and",
"streaming",
"output",
"calls",
"on",
"the",
"service"
] |
[
"public",
"static",
"load",
"balancer",
"blocking",
"stub",
"new",
"blocking",
"stub",
"(",
"io",
"grpc",
"channel",
"channel",
")",
"{",
"io",
"grpc",
"stub",
"abstract",
"stub",
"stub",
"factory",
"<",
"load",
"balancer",
"blocking",
"stub",
">",
"factory",
"=",
"new",
"io",
"grpc",
"stub",
"abstract",
"stub",
"stub",
"factory",
"<",
"load",
"balancer",
"blocking",
"stub",
">",
"(",
")",
"{",
"@",
"java",
"lang",
"override",
"public",
"load",
"balancer",
"blocking",
"stub",
"new",
"stub",
"(",
"io",
"grpc",
"channel",
"channel",
",",
"io",
"grpc",
"call",
"options",
"call",
"options",
")",
"{",
"return",
"new",
"load",
"balancer",
"blocking",
"stub",
"(",
"channel",
",",
"call",
"options",
")",
";",
"}",
"}",
";",
"return",
"load",
"balancer",
"blocking",
"stub",
"new",
"stub",
"(",
"factory",
",",
"channel",
")",
";",
"}"
] |
[
"makes",
"our",
"egl",
"context",
"and",
"surface",
"current"
] |
[
"private",
"void",
"make",
"current",
"(",
")",
"throws",
"transcoding",
"exception",
"{",
"if",
"(",
"m",
"e",
"g",
"l",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"transcoding",
"exception",
"(",
"\"",
"not",
"configured",
"for",
"make",
"current",
"\"",
")",
";",
"}",
"check",
"egl",
"error",
"(",
"\"",
"before",
"make",
"current",
"\"",
")",
";",
"if",
"(",
"!",
"m",
"e",
"g",
"l",
"egl",
"make",
"current",
"(",
"m",
"e",
"g",
"l",
"display",
",",
"m",
"e",
"g",
"l",
"surface",
",",
"m",
"e",
"g",
"l",
"surface",
",",
"m",
"e",
"g",
"l",
"context",
")",
")",
"{",
"throw",
"new",
"transcoding",
"exception",
"(",
"\"",
"egl",
"make",
"current",
"failed",
"\"",
")",
";",
"}",
"}"
] |
[
"returns",
"context",
"registered",
"for",
"the",
"given",
"type",
"note",
"that",
"multiple",
"contexts",
"could",
"have",
"been",
"registered",
"for",
"the",
"same",
"identifying",
"type",
"in",
"this",
"case",
"the",
"last",
"such",
"registered",
"context",
"will",
"be",
"returned",
"here",
"contexts",
"of",
"the",
"same",
"type",
"can",
"also",
"be",
"distinguished",
"using",
"command",
"-",
"line",
"identifiers",
"and",
"some",
"can",
"be",
"{",
"@",
"linkplain",
"com",
"google",
"devtools",
"build",
"lib",
"exec",
"executor",
"builder",
"#",
"add",
"strategy",
"by",
"context",
"excluded",
"}",
"from",
"the",
"registry",
"based",
"on",
"those",
"identifiers"
] |
[
"<",
"t",
"extends",
"action",
"context",
">",
"t",
"get",
"context",
"(",
"class",
"<",
"t",
">",
"identifying",
"type",
")",
";"
] |
[
"build",
"the",
"diagnostic",
"message",
"and",
"update",
"it"
] |
[
"private",
"void",
"update",
"a",
"m",
"diagnostic",
"msg",
"(",
"resource",
"resource",
",",
"string",
"reason",
")",
"{",
"if",
"(",
"!",
"is",
"waiting",
"for",
"a",
"m",
"container",
"(",
")",
")",
"{",
"return",
";",
"}",
"string",
"builder",
"diagnostic",
"message",
"=",
"new",
"string",
"builder",
"(",
")",
";",
"diagnostic",
"message",
"append",
"(",
"\"",
"(",
"resource",
"request",
":",
"\"",
")",
"append",
"(",
"resource",
")",
"append",
"(",
"reason",
")",
";",
"update",
"a",
"m",
"container",
"diagnostics",
"(",
"a",
"m",
"state",
"inactivated",
",",
"diagnostic",
"message",
"to",
"string",
"(",
")",
")",
";",
"}"
] |
[
"create",
"a",
"remote",
"iterator",
"from",
"a",
"single",
"status",
"entry"
] |
[
"public",
"remote",
"iterator",
"<",
"s",
"3",
"a",
"located",
"file",
"status",
">",
"create",
"single",
"status",
"iterator",
"(",
"s",
"3",
"a",
"located",
"file",
"status",
"status",
")",
"{",
"return",
"remote",
"iterator",
"from",
"singleton",
"(",
"status",
")",
";",
"}"
] |
[
"shutdown",
"{",
"@",
"link",
"hystrix",
"request",
"variable",
"default",
"}",
"objects",
"in",
"this",
"context",
"<",
"b",
">",
"note",
":",
"this",
"must",
"be",
"called",
"if",
"<",
"code",
">",
"initialize",
"context",
"(",
")",
"<",
"code",
">",
"was",
"called",
"or",
"a",
"memory",
"leak",
"will",
"occur",
"<",
"b",
">"
] |
[
"public",
"void",
"shutdown",
"(",
")",
"{",
"if",
"(",
"state",
"!",
"=",
"null",
")",
"{",
"for",
"(",
"hystrix",
"request",
"variable",
"default",
"<",
"?",
">",
"v",
":",
"state",
"key",
"set",
"(",
")",
")",
"{",
"/",
"/",
"for",
"each",
"request",
"variable",
"we",
"call",
"'",
"remove",
"'",
"which",
"performs",
"the",
"shutdown",
"logic",
"try",
"{",
"hystrix",
"request",
"variable",
"default",
"remove",
"(",
"this",
",",
"v",
")",
";",
"}",
"catch",
"(",
"throwable",
"t",
")",
"{",
"hystrix",
"request",
"variable",
"default",
"logger",
"error",
"(",
"\"",
"error",
"in",
"shutdown",
",",
"will",
"continue",
"with",
"shutdown",
"of",
"other",
"variables",
"\"",
",",
"t",
")",
";",
"}",
"}",
"/",
"/",
"null",
"out",
"so",
"it",
"can",
"be",
"garbage",
"collected",
"even",
"if",
"the",
"containing",
"object",
"is",
"still",
"/",
"/",
"being",
"held",
"in",
"thread",
"locals",
"on",
"threads",
"that",
"weren",
"'",
"t",
"cleaned",
"up",
"state",
"=",
"null",
";",
"}",
"}"
] |
[
"set",
"the",
"{",
"@",
"link",
"destination",
"resolver",
"}",
"to",
"use",
"when",
"falling",
"back",
"to",
"dynamic",
"destinations",
"the",
"default",
"is",
"spring",
"'",
"s",
"standard",
"{",
"@",
"link",
"dynamic",
"destination",
"resolver",
"}"
] |
[
"public",
"void",
"set",
"dynamic",
"destination",
"resolver",
"(",
"destination",
"resolver",
"dynamic",
"destination",
"resolver",
")",
"{",
"this",
"dynamic",
"destination",
"resolver",
"=",
"dynamic",
"destination",
"resolver",
";",
"}"
] |
[
"test",
"to",
"validate",
"correct",
"exception",
"is",
"thrown",
"for",
"multithreaded",
"seek",
"scenario",
"for",
"page",
"blobs"
] |
[
"public",
"void",
"test",
"multi",
"threaded",
"page",
"blob",
"seek",
"scenario",
"(",
")",
"throws",
"throwable",
"{",
"bind",
"to",
"test",
"account",
"(",
"get",
"page",
"blob",
"test",
"storage",
"account",
"(",
")",
")",
";",
"path",
"base",
"=",
"method",
"path",
"(",
")",
";",
"path",
"test",
"file",
"path",
"1",
"=",
"new",
"path",
"(",
"base",
",",
"\"",
"test",
"1",
"dat",
"\"",
")",
";",
"path",
"rename",
"path",
"=",
"new",
"path",
"(",
"base",
",",
"\"",
"test",
"2",
"dat",
"\"",
")",
";",
"get",
"input",
"stream",
"to",
"test",
"(",
"fs",
",",
"test",
"file",
"path",
"1",
")",
";",
"thread",
"rename",
"thread",
"=",
"new",
"thread",
"(",
"new",
"rename",
"thread",
"(",
"fs",
",",
"test",
"file",
"path",
"1",
",",
"rename",
"path",
")",
")",
";",
"rename",
"thread",
"start",
"(",
")",
";",
"rename",
"thread",
"join",
"(",
")",
";",
"input",
"stream",
"seek",
"(",
"5",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"number",
"item",
"'"
] |
[
"public",
"void",
"number",
"item",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"number",
"item",
"}"
] |
[
"subtasks",
"that",
"have",
"not",
"provided",
"a",
"watermark",
"update",
"within",
"the",
"configured",
"interval",
"will",
"be",
"considered",
"idle",
"and",
"excluded",
"from",
"target",
"watermark",
"calculation"
] |
[
"public",
"void",
"set",
"update",
"timeout",
"millis",
"(",
"long",
"update",
"timeout",
"millis",
")",
"{",
"this",
"update",
"timeout",
"millis",
"=",
"update",
"timeout",
"millis",
";",
"}"
] |
[
"gets",
"a",
"url",
"as",
"a",
"reader"
] |
[
"public",
"static",
"reader",
"get",
"url",
"as",
"reader",
"(",
"string",
"url",
"string",
")",
"throws",
"i",
"o",
"exception",
"{",
"reader",
"reader",
";",
"if",
"(",
"charset",
"=",
"=",
"null",
")",
"{",
"reader",
"=",
"new",
"input",
"stream",
"reader",
"(",
"get",
"url",
"as",
"stream",
"(",
"url",
"string",
")",
")",
";",
"}",
"else",
"{",
"reader",
"=",
"new",
"input",
"stream",
"reader",
"(",
"get",
"url",
"as",
"stream",
"(",
"url",
"string",
")",
",",
"charset",
")",
";",
"}",
"return",
"reader",
";",
"}"
] |
[
"create",
"remote",
"exception",
"from",
"attributes"
] |
[
"public",
"static",
"remote",
"exception",
"value",
"of",
"(",
"attributes",
"attrs",
")",
"{",
"return",
"new",
"remote",
"exception",
"(",
"attrs",
"get",
"value",
"(",
"\"",
"class",
"\"",
")",
",",
"attrs",
"get",
"value",
"(",
"\"",
"message",
"\"",
")",
")",
";",
"}"
] |
[
"sets",
"flags",
"for",
"{",
"@",
"link",
"mp",
"4",
"extractor",
"}",
"instances",
"created",
"by",
"the",
"factory"
] |
[
"public",
"synchronized",
"default",
"extractors",
"factory",
"set",
"mp",
"4",
"extractor",
"flags",
"(",
"@",
"mp",
"4",
"extractor",
"flags",
"int",
"flags",
")",
"{",
"this",
"mp",
"4",
"flags",
"=",
"flags",
";",
"return",
"this",
";",
"}"
] |
[
"take",
"a",
"time",
"step",
"this",
"performs",
"collision",
"detection",
",",
"integration",
",",
"and",
"constraint",
"solution"
] |
[
"public",
"void",
"step",
"(",
"float",
"dt",
",",
"int",
"velocity",
"iterations",
",",
"int",
"position",
"iterations",
")",
"{",
"step",
"timer",
"reset",
"(",
")",
";",
"temp",
"timer",
"reset",
"(",
")",
";",
"/",
"/",
"log",
"debug",
"(",
"\"",
"starting",
"step",
"\"",
")",
";",
"/",
"/",
"if",
"new",
"fixtures",
"were",
"added",
",",
"we",
"need",
"to",
"find",
"the",
"new",
"contacts",
"if",
"(",
"(",
"m",
"flags",
"&",
"new",
"fixture",
")",
"=",
"=",
"new",
"fixture",
")",
"{",
"/",
"/",
"log",
"debug",
"(",
"\"",
"there",
"'",
"s",
"a",
"new",
"fixture",
",",
"lets",
"look",
"for",
"new",
"contacts",
"\"",
")",
";",
"m",
"contact",
"manager",
"find",
"new",
"contacts",
"(",
")",
";",
"m",
"flags",
"&",
"=",
"~",
"new",
"fixture",
";",
"}",
"m",
"flags",
"|",
"=",
"locked",
";",
"step",
"dt",
"=",
"dt",
";",
"step",
"velocity",
"iterations",
"=",
"velocity",
"iterations",
";",
"step",
"position",
"iterations",
"=",
"position",
"iterations",
";",
"if",
"(",
"dt",
">",
"0",
"0f",
")",
"{",
"step",
"inv",
"dt",
"=",
"1",
"0f",
"/",
"dt",
";",
"}",
"else",
"{",
"step",
"inv",
"dt",
"=",
"0",
"0f",
";",
"}",
"step",
"dt",
"ratio",
"=",
"m",
"inv",
"dt",
"0",
"*",
"dt",
";",
"step",
"warm",
"starting",
"=",
"m",
"warm",
"starting",
";",
"m",
"profile",
"step",
"init",
"record",
"(",
"temp",
"timer",
"get",
"milliseconds",
"(",
")",
")",
";",
"/",
"/",
"update",
"contacts",
"this",
"is",
"where",
"some",
"contacts",
"are",
"destroyed",
"temp",
"timer",
"reset",
"(",
")",
";",
"m",
"contact",
"manager",
"collide",
"(",
")",
";",
"m",
"profile",
"collide",
"record",
"(",
"temp",
"timer",
"get",
"milliseconds",
"(",
")",
")",
";",
"/",
"/",
"integrate",
"velocities",
",",
"solve",
"velocity",
"constraints",
",",
"and",
"integrate",
"positions",
"if",
"(",
"m",
"step",
"complete",
"&",
"&",
"step",
"dt",
">",
"0",
"0f",
")",
"{",
"temp",
"timer",
"reset",
"(",
")",
";",
"m",
"particle",
"system",
"solve",
"(",
"step",
")",
";",
"/",
"/",
"particle",
"simulation",
"m",
"profile",
"solve",
"particle",
"system",
"record",
"(",
"temp",
"timer",
"get",
"milliseconds",
"(",
")",
")",
";",
"temp",
"timer",
"reset",
"(",
")",
";",
"solve",
"(",
"step",
")",
";",
"m",
"profile",
"solve",
"record",
"(",
"temp",
"timer",
"get",
"milliseconds",
"(",
")",
")",
";",
"}",
"/",
"/",
"handle",
"toi",
"events",
"if",
"(",
"m",
"continuous",
"physics",
"&",
"&",
"step",
"dt",
">",
"0",
"0f",
")",
"{",
"temp",
"timer",
"reset",
"(",
")",
";",
"solve",
"t",
"o",
"i",
"(",
"step",
")",
";",
"m",
"profile",
"solve",
"t",
"o",
"i",
"record",
"(",
"temp",
"timer",
"get",
"milliseconds",
"(",
")",
")",
";",
"}",
"if",
"(",
"step",
"dt",
">",
"0",
"0f",
")",
"{",
"m",
"inv",
"dt",
"0",
"=",
"step",
"inv",
"dt",
";",
"}",
"if",
"(",
"(",
"m",
"flags",
"&",
"clear",
"forces",
")",
"=",
"=",
"clear",
"forces",
")",
"{",
"clear",
"forces",
"(",
")",
";",
"}",
"m",
"flags",
"&",
"=",
"~",
"locked",
";",
"/",
"/",
"log",
"debug",
"(",
"\"",
"ending",
"step",
"\"",
")",
";",
"m",
"profile",
"step",
"record",
"(",
"step",
"timer",
"get",
"milliseconds",
"(",
")",
")",
";",
"}"
] |
[
"render",
"the",
"template",
"with",
"the",
"given",
"{",
"@",
"code",
"name",
"}",
"using",
"the",
"given",
"{",
"@",
"code",
"model",
"attributes",
"}",
"the",
"model",
"attributes",
"are",
"mapped",
"under",
"a",
"{",
"@",
"linkplain",
"org",
"springframework",
"core",
"conventions",
"#",
"get",
"variable",
"name",
"generated",
"name",
"}",
"note",
":",
"empty",
"{",
"@",
"link",
"collection",
"collections",
"}",
"are",
"not",
"added",
"to",
"the",
"model",
"when",
"using",
"this",
"method",
"because",
"we",
"cannot",
"correctly",
"determine",
"the",
"true",
"convention",
"name"
] |
[
"mono",
"<",
"server",
"response",
">",
"render",
"(",
"string",
"name",
",",
"object",
"model",
"attributes",
")",
";"
] |
[
"returns",
"matching",
"edit",
"logs",
"via",
"the",
"log",
"directory",
"simple",
"helper",
"function",
"that",
"lists",
"the",
"files",
"in",
"the",
"log",
"dir",
"and",
"calls",
"match",
"edit",
"logs",
"(",
"file",
"[",
"]",
")"
] |
[
"public",
"static",
"list",
"<",
"edit",
"log",
"file",
">",
"match",
"edit",
"logs",
"(",
"file",
"log",
"dir",
")",
"throws",
"i",
"o",
"exception",
"{",
"return",
"match",
"edit",
"logs",
"(",
"file",
"util",
"list",
"files",
"(",
"log",
"dir",
")",
")",
";",
"}"
] |
[
"<",
"code",
">",
"optional",
"aapt",
"pb",
"primitive",
"prim",
"=",
"7",
";",
"<",
"code",
">"
] |
[
"public",
"builder",
"set",
"prim",
"(",
"com",
"android",
"aapt",
"resources",
"primitive",
"builder",
"builder",
"for",
"value",
")",
"{",
"copy",
"on",
"write",
"(",
")",
";",
"instance",
"set",
"prim",
"(",
"builder",
"for",
"value",
")",
";",
"return",
"this",
";",
"}"
] |
[
"performs",
"key",
"stretching",
"in",
"the",
"same",
"manner",
"that",
"open",
"s",
"s",
"l",
"does",
"this",
"is",
"basically",
"a",
"kdf",
"that",
"uses",
"n",
"rounds",
"of",
"salted",
"md5",
"(",
"as",
"many",
"times",
"as",
"needed",
"to",
"get",
"the",
"necessary",
"number",
"of",
"key",
"bytes",
")",
"https",
":",
"www",
"openssl",
"orgdocsman",
"1",
"1",
"0crypto",
"p",
"e",
"m",
"write",
"bio",
"private",
"key",
"traditional",
"html"
] |
[
"private",
"static",
"byte",
"[",
"]",
"generate",
"open",
"ssl",
"key",
"(",
"char",
"[",
"]",
"password",
",",
"byte",
"[",
"]",
"salt",
",",
"int",
"key",
"length",
")",
"{",
"byte",
"[",
"]",
"password",
"bytes",
"=",
"char",
"arrays",
"to",
"utf",
"8",
"bytes",
"(",
"password",
")",
";",
"message",
"digest",
"md",
"5",
"=",
"message",
"digests",
"md",
"5",
"(",
")",
";",
"byte",
"[",
"]",
"key",
"=",
"new",
"byte",
"[",
"key",
"length",
"]",
";",
"int",
"copied",
"=",
"0",
";",
"int",
"remaining",
";",
"while",
"(",
"copied",
"<",
"key",
"length",
")",
"{",
"remaining",
"=",
"key",
"length",
"-",
"copied",
";",
"md",
"5",
"update",
"(",
"password",
"bytes",
",",
"0",
",",
"password",
"bytes",
"length",
")",
";",
"md",
"5",
"update",
"(",
"salt",
",",
"0",
",",
"8",
")",
";",
"/",
"/",
"aes",
"iv",
"(",
"salt",
")",
"is",
"longer",
"but",
"we",
"only",
"need",
"8",
"bytes",
"byte",
"[",
"]",
"temp",
"digest",
"=",
"md",
"5",
"digest",
"(",
")",
";",
"int",
"bytes",
"to",
"copy",
"=",
"(",
"remaining",
">",
"16",
")",
"?",
"16",
":",
"remaining",
";",
"/",
"/",
"md5",
"digests",
"are",
"16",
"bytes",
"system",
"arraycopy",
"(",
"temp",
"digest",
",",
"0",
",",
"key",
",",
"copied",
",",
"bytes",
"to",
"copy",
")",
";",
"copied",
"+",
"=",
"bytes",
"to",
"copy",
";",
"if",
"(",
"remaining",
"=",
"=",
"0",
")",
"{",
"break",
";",
"}",
"md",
"5",
"update",
"(",
"temp",
"digest",
",",
"0",
",",
"16",
")",
";",
"/",
"/",
"use",
"previous",
"round",
"digest",
"as",
"iv",
"}",
"arrays",
"fill",
"(",
"password",
"bytes",
",",
"(",
"byte",
")",
"0",
")",
";",
"return",
"key",
";",
"}"
] |
[
"get",
"net",
"exception",
"type"
] |
[
"public",
"static",
"net",
"exception",
"type",
"get",
"net",
"exception",
"type",
"(",
"throwable",
"throwable",
")",
"{",
"throwable",
"current",
"cause",
"=",
"throwable",
";",
"int",
"dep",
"=",
"max",
"cause",
"dep",
";",
"while",
"(",
"current",
"cause",
"!",
"=",
"null",
"&",
"&",
"dep",
">",
"0",
")",
"{",
"if",
"(",
"current",
"cause",
"instanceof",
"java",
"net",
"socket",
"timeout",
"exception",
")",
"{",
"if",
"(",
"connect",
"timed",
"out",
"equals",
"(",
"current",
"cause",
"get",
"message",
"(",
")",
")",
")",
"{",
"return",
"net",
"exception",
"type",
"connect",
"timeout",
"exception",
";",
"}",
"else",
"{",
"return",
"net",
"exception",
"type",
"read",
"timeout",
"exception",
";",
"}",
"}",
"else",
"if",
"(",
"current",
"cause",
"instanceof",
"java",
"net",
"connect",
"exception",
")",
"{",
"return",
"net",
"exception",
"type",
"connect",
"exception",
";",
"}",
"else",
"if",
"(",
"current",
"cause",
"get",
"class",
"(",
")",
"get",
"simple",
"name",
"(",
")",
"contains",
"(",
"connect",
"time",
"out",
"exception",
"class",
"name",
")",
")",
"{",
"return",
"net",
"exception",
"type",
"connect",
"timeout",
"exception",
";",
"}",
"else",
"if",
"(",
"current",
"cause",
"get",
"class",
"(",
")",
"get",
"simple",
"name",
"(",
")",
"contains",
"(",
"read",
"time",
"out",
"exception",
"class",
"name",
")",
")",
"{",
"return",
"net",
"exception",
"type",
"read",
"timeout",
"exception",
";",
"}",
"else",
"if",
"(",
"current",
"cause",
"get",
"class",
"(",
")",
"get",
"simple",
"name",
"(",
")",
"contains",
"(",
"connect",
"exception",
"class",
"name",
")",
")",
"{",
"return",
"net",
"exception",
"type",
"connect",
"exception",
";",
"}",
"else",
"{",
"throwable",
"parent",
"cause",
"=",
"current",
"cause",
"get",
"cause",
"(",
")",
";",
"if",
"(",
"parent",
"cause",
"=",
"=",
"null",
"|",
"|",
"parent",
"cause",
"=",
"=",
"current",
"cause",
")",
"{",
"break",
";",
"}",
"current",
"cause",
"=",
"parent",
"cause",
";",
"dep",
"-",
"-",
";",
"}",
"}",
"return",
"net",
"exception",
"type",
"not",
"net",
"exception",
";",
"}"
] |
[
"tests",
"that",
"checkpoints",
"are",
"declined",
"if",
"operators",
"are",
"(",
"partially",
")",
"closed",
"see",
"flink",
"-",
"16383"
] |
[
"public",
"void",
"test",
"checkpoint",
"declined",
"on",
"closed",
"operator",
"(",
")",
"throws",
"throwable",
"{",
"closing",
"operator",
"operator",
"=",
"new",
"closing",
"operator",
"(",
")",
";",
"stream",
"task",
"mailbox",
"test",
"harness",
"builder",
"<",
"integer",
">",
"builder",
"=",
"new",
"stream",
"task",
"mailbox",
"test",
"harness",
"builder",
"<",
">",
"(",
"one",
"input",
"stream",
"task",
":",
":",
"new",
",",
"basic",
"type",
"info",
"int",
"type",
"info",
")",
"add",
"input",
"(",
"basic",
"type",
"info",
"int",
"type",
"info",
")",
";",
"stream",
"task",
"mailbox",
"test",
"harness",
"<",
"integer",
">",
"harness",
"=",
"builder",
"setup",
"output",
"for",
"singleton",
"operator",
"chain",
"(",
"operator",
")",
"build",
"(",
")",
";",
"/",
"/",
"keeps",
"the",
"mailbox",
"from",
"suspending",
"harness",
"set",
"auto",
"process",
"(",
"false",
")",
";",
"harness",
"process",
"element",
"(",
"new",
"stream",
"record",
"<",
">",
"(",
"1",
")",
")",
";",
"harness",
"stream",
"task",
"operator",
"chain",
"close",
"operators",
"(",
"harness",
"stream",
"task",
"get",
"action",
"executor",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"true",
",",
"operator",
"closed",
"get",
"(",
")",
")",
";",
"harness",
"stream",
"task",
"trigger",
"checkpoint",
"on",
"barrier",
"(",
"new",
"checkpoint",
"meta",
"data",
"(",
"1",
",",
"0",
")",
",",
"checkpoint",
"options",
"for",
"checkpoint",
"with",
"default",
"location",
"(",
")",
",",
"new",
"checkpoint",
"metrics",
"builder",
"(",
")",
")",
";",
"assert",
"equals",
"(",
"1",
",",
"harness",
"get",
"checkpoint",
"responder",
"(",
")",
"get",
"decline",
"reports",
"(",
")",
"size",
"(",
")",
")",
";",
"}"
] |
[
"returns",
"true",
"if",
"there",
"is",
"an",
"edge",
"that",
"directly",
"connects",
"{",
"@",
"code",
"endpoints",
"}",
"(",
"in",
"the",
"order",
",",
"if",
"any",
",",
"specified",
"by",
"{",
"@",
"code",
"endpoints",
"}",
")",
"this",
"is",
"equivalent",
"to",
"{",
"@",
"code",
"edges",
"(",
")",
"contains",
"(",
"endpoints",
")",
"}",
"unlike",
"the",
"other",
"{",
"@",
"code",
"endpoint",
"pair",
"}",
"-",
"accepting",
"methods",
",",
"this",
"method",
"does",
"not",
"throw",
"if",
"the",
"endpoints",
"are",
"unordered",
";",
"it",
"simply",
"returns",
"false",
"this",
"is",
"for",
"consistency",
"with",
"the",
"behavior",
"of",
"{",
"@",
"link",
"collection",
"#",
"contains",
"(",
"object",
")",
"}",
"(",
"which",
"does",
"not",
"generally",
"throw",
"if",
"the",
"object",
"cannot",
"be",
"present",
"in",
"the",
"collection",
")",
",",
"and",
"the",
"desire",
"to",
"have",
"this",
"method",
"'",
"s",
"behavior",
"be",
"compatible",
"with",
"{",
"@",
"code",
"edges",
"(",
")",
"contains",
"(",
"endpoints",
")",
"}"
] |
[
"boolean",
"has",
"edge",
"connecting",
"(",
"endpoint",
"pair",
"<",
"n",
">",
"endpoints",
")",
";"
] |
[
"returns",
"the",
"{",
"@",
"link",
"downloadable",
"}",
"that",
"has",
"the",
"given",
"id"
] |
[
"public",
"static",
"downloadable",
"get",
"(",
"string",
"id",
")",
"{",
"for",
"(",
"downloadable",
"d",
":",
"all",
"(",
")",
")",
"{",
"if",
"(",
"d",
"id",
"equals",
"(",
"id",
")",
")",
"return",
"d",
";",
"}",
"return",
"null",
";",
"}"
] |
[
"model",
"tests",
"for",
"model",
"api",
"response"
] |
[
"public",
"void",
"test",
"model",
"api",
"response",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"model",
"api",
"response",
"}"
] |
[
"get",
"the",
"names",
"of",
"all",
"clients"
] |
[
"private",
"synchronized",
"string",
"clients",
"string",
"(",
")",
"{",
"if",
"(",
"dfsclients",
"is",
"empty",
"(",
")",
")",
"{",
"return",
"\"",
"[",
"]",
"\"",
";",
"}",
"else",
"{",
"final",
"string",
"builder",
"b",
"=",
"new",
"string",
"builder",
"(",
"\"",
"[",
"\"",
")",
"append",
"(",
"dfsclients",
"get",
"(",
"0",
")",
"get",
"client",
"name",
"(",
")",
")",
";",
"for",
"(",
"int",
"i",
"=",
"1",
";",
"i",
"<",
"dfsclients",
"size",
"(",
")",
";",
"i",
"+",
"+",
")",
"{",
"b",
"append",
"(",
"\"",
",",
"\"",
")",
"append",
"(",
"dfsclients",
"get",
"(",
"i",
")",
"get",
"client",
"name",
"(",
")",
")",
";",
"}",
"return",
"b",
"append",
"(",
"\"",
"]",
"\"",
")",
"to",
"string",
"(",
")",
";",
"}",
"}"
] |
[
"test",
"the",
"property",
"'",
"any",
"type",
"prop",
"'"
] |
[
"public",
"void",
"any",
"type",
"prop",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"any",
"type",
"prop",
"}"
] |
[
"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",
"model",
"no",
"validation",
"on",
"visibility",
"changed",
"(",
"on",
"model",
"visibility",
"changed",
"listener",
"<",
"model",
"no",
"validation",
",",
"object",
">",
"listener",
")",
"{",
"on",
"mutation",
"(",
")",
";",
"this",
"on",
"model",
"visibility",
"changed",
"listener",
"epoxy",
"generated",
"model",
"=",
"listener",
";",
"return",
"this",
";",
"}"
] |
[
"gets",
"the",
"maximum",
"stack",
"size",
"for",
"this",
"instance"
] |
[
"public",
"int",
"get",
"max",
"stack",
"(",
")",
"{",
"return",
"stack",
"length",
";",
"}"
] |
[
"return",
"the",
"number",
"of",
"currently",
"-",
"executing",
"hystrix",
"threads"
] |
[
"public",
"static",
"int",
"get",
"global",
"concurrent",
"threads",
"executing",
"(",
")",
"{",
"return",
"concurrent",
"threads",
"executing",
"get",
"(",
")",
";",
"}"
] |
[
"add",
"block",
"to",
"the",
"replicate",
"blocks",
"queue",
"of",
"the",
"datanode"
] |
[
"public",
"static",
"void",
"add",
"block",
"to",
"be",
"replicated",
"(",
"datanode",
"descriptor",
"node",
",",
"block",
"block",
",",
"datanode",
"storage",
"info",
"[",
"]",
"targets",
")",
"{",
"node",
"add",
"block",
"to",
"be",
"replicated",
"(",
"block",
",",
"targets",
")",
";",
"}"
] |
[
"performs",
"the",
"actual",
"refresh",
"of",
"the",
"token",
"with",
"retries",
"in",
"case",
"of",
"certain",
"exceptions",
"that",
"may",
"be",
"recoverable",
"the",
"refresh",
"involves",
"two",
"steps",
":",
"first",
",",
"we",
"check",
"if",
"the",
"token",
"document",
"is",
"still",
"valid",
"for",
"refresh",
"then",
",",
"in",
"the",
"case",
"that",
"the",
"token",
"has",
"been",
"refreshed",
"within",
"the",
"previous",
"30",
"seconds",
",",
"we",
"do",
"not",
"create",
"a",
"new",
"token",
"document",
"but",
"instead",
"retrieve",
"the",
"one",
"that",
"was",
"created",
"by",
"the",
"original",
"refresh",
"and",
"return",
"an",
"access",
"token",
"and",
"refresh",
"token",
"based",
"on",
"that",
"otherwise",
"this",
"token",
"document",
"gets",
"its",
"refresh",
"token",
"marked",
"as",
"refreshed",
",",
"while",
"also",
"storing",
"the",
"instant",
"when",
"it",
"was",
"refreshed",
"along",
"with",
"a",
"pointer",
"to",
"the",
"new",
"token",
"document",
"that",
"holds",
"the",
"refresh",
"token",
"that",
"supersedes",
"this",
"one",
"the",
"new",
"document",
"that",
"contains",
"the",
"new",
"access",
"token",
"and",
"refresh",
"token",
"is",
"created",
"and",
"finally",
"the",
"new",
"access",
"token",
"and",
"refresh",
"token",
"are",
"returned",
"to",
"the",
"listener"
] |
[
"private",
"void",
"inner",
"refresh",
"(",
"string",
"refresh",
"token",
",",
"string",
"token",
"doc",
"id",
",",
"map",
"<",
"string",
",",
"object",
">",
"source",
",",
"long",
"seq",
"no",
",",
"long",
"primary",
"term",
",",
"authentication",
"client",
"auth",
",",
"iterator",
"<",
"time",
"value",
">",
"backoff",
",",
"instant",
"refresh",
"requested",
",",
"action",
"listener",
"<",
"create",
"token",
"result",
">",
"listener",
")",
"{",
"logger",
"debug",
"(",
"\"",
"attempting",
"to",
"refresh",
"token",
"stored",
"in",
"token",
"document",
"[",
"{",
"}",
"]",
"\"",
",",
"token",
"doc",
"id",
")",
";",
"final",
"consumer",
"<",
"exception",
">",
"on",
"failure",
"=",
"ex",
"-",
">",
"listener",
"on",
"failure",
"(",
"trace",
"log",
"(",
"\"",
"refresh",
"token",
"\"",
",",
"token",
"doc",
"id",
",",
"ex",
")",
")",
";",
"final",
"tuple",
"<",
"refresh",
"token",
"status",
",",
"optional",
"<",
"elasticsearch",
"security",
"exception",
">",
">",
"check",
"refresh",
"result",
";",
"try",
"{",
"check",
"refresh",
"result",
"=",
"check",
"token",
"document",
"for",
"refresh",
"(",
"refresh",
"requested",
",",
"client",
"auth",
",",
"source",
")",
";",
"}",
"catch",
"(",
"date",
"time",
"exception",
"|",
"illegal",
"state",
"exception",
"e",
")",
"{",
"on",
"failure",
"accept",
"(",
"new",
"elasticsearch",
"security",
"exception",
"(",
"\"",
"invalid",
"token",
"document",
"\"",
",",
"e",
")",
")",
";",
"return",
";",
"}",
"if",
"(",
"check",
"refresh",
"result",
"v",
"2",
"(",
")",
"is",
"present",
"(",
")",
")",
"{",
"on",
"failure",
"accept",
"(",
"check",
"refresh",
"result",
"v",
"2",
"(",
")",
"get",
"(",
")",
")",
";",
"return",
";",
"}",
"final",
"refresh",
"token",
"status",
"refresh",
"token",
"status",
"=",
"check",
"refresh",
"result",
"v",
"1",
"(",
")",
";",
"final",
"security",
"index",
"manager",
"refreshed",
"token",
"index",
"=",
"get",
"tokens",
"index",
"for",
"version",
"(",
"refresh",
"token",
"status",
"get",
"version",
"(",
")",
")",
";",
"if",
"(",
"refresh",
"token",
"status",
"is",
"refreshed",
"(",
")",
")",
"{",
"logger",
"debug",
"(",
"\"",
"token",
"document",
"[",
"{",
"}",
"]",
"was",
"recently",
"refreshed",
",",
"when",
"a",
"new",
"token",
"document",
"was",
"generated",
"reusing",
"that",
"result",
"\"",
",",
"token",
"doc",
"id",
")",
";",
"final",
"tuple",
"<",
"user",
"token",
",",
"string",
">",
"parsed",
"tokens",
"=",
"parse",
"tokens",
"from",
"document",
"(",
"source",
",",
"null",
")",
";",
"authentication",
"authentication",
"=",
"parsed",
"tokens",
"v",
"1",
"(",
")",
"get",
"authentication",
"(",
")",
";",
"decrypt",
"and",
"return",
"superseding",
"tokens",
"(",
"refresh",
"token",
",",
"refresh",
"token",
"status",
",",
"refreshed",
"token",
"index",
",",
"authentication",
",",
"listener",
")",
";",
"}",
"else",
"{",
"final",
"string",
"new",
"access",
"token",
"string",
"=",
"u",
"u",
"i",
"ds",
"random",
"base",
"6",
"4",
"u",
"u",
"i",
"d",
"(",
")",
";",
"final",
"string",
"new",
"refresh",
"token",
"string",
"=",
"u",
"u",
"i",
"ds",
"random",
"base",
"6",
"4",
"u",
"u",
"i",
"d",
"(",
")",
";",
"final",
"version",
"new",
"token",
"version",
"=",
"get",
"token",
"version",
"compatibility",
"(",
")",
";",
"final",
"map",
"<",
"string",
",",
"object",
">",
"update",
"map",
"=",
"new",
"hash",
"map",
"<",
">",
"(",
")",
";",
"update",
"map",
"put",
"(",
"\"",
"refreshed",
"\"",
",",
"true",
")",
";",
"if",
"(",
"new",
"token",
"version",
"on",
"or",
"after",
"(",
"version",
"multiple",
"concurrent",
"refreshes",
")",
")",
"{",
"update",
"map",
"put",
"(",
"\"",
"refresh",
"time",
"\"",
",",
"clock",
"instant",
"(",
")",
"to",
"epoch",
"milli",
"(",
")",
")",
";",
"try",
"{",
"final",
"byte",
"[",
"]",
"iv",
"=",
"get",
"random",
"bytes",
"(",
"iv",
"bytes",
")",
";",
"final",
"byte",
"[",
"]",
"salt",
"=",
"get",
"random",
"bytes",
"(",
"salt",
"bytes",
")",
";",
"string",
"encrypted",
"access",
"and",
"refresh",
"token",
"=",
"encrypt",
"superseding",
"tokens",
"(",
"new",
"access",
"token",
"string",
",",
"new",
"refresh",
"token",
"string",
",",
"refresh",
"token",
",",
"iv",
",",
"salt",
")",
";",
"update",
"map",
"put",
"(",
"\"",
"superseding",
"encrypted",
"tokens",
"\"",
",",
"encrypted",
"access",
"and",
"refresh",
"token",
")",
";",
"update",
"map",
"put",
"(",
"\"",
"superseding",
"encryption",
"iv",
"\"",
",",
"base",
"6",
"4",
"get",
"encoder",
"(",
")",
"encode",
"to",
"string",
"(",
"iv",
")",
")",
";",
"update",
"map",
"put",
"(",
"\"",
"superseding",
"encryption",
"salt",
"\"",
",",
"base",
"6",
"4",
"get",
"encoder",
"(",
")",
"encode",
"to",
"string",
"(",
"salt",
")",
")",
";",
"}",
"catch",
"(",
"general",
"security",
"exception",
"e",
")",
"{",
"logger",
"warn",
"(",
"\"",
"could",
"not",
"encrypt",
"access",
"token",
"and",
"refresh",
"token",
"string",
"\"",
",",
"e",
")",
";",
"on",
"failure",
"accept",
"(",
"invalid",
"grant",
"exception",
"(",
"\"",
"could",
"not",
"refresh",
"the",
"requested",
"token",
"\"",
")",
")",
";",
"}",
"}",
"assert",
"seq",
"no",
"!",
"=",
"sequence",
"numbers",
"unassigned",
"seq",
"no",
":",
"\"",
"expected",
"an",
"assigned",
"sequence",
"number",
"\"",
";",
"assert",
"primary",
"term",
"!",
"=",
"sequence",
"numbers",
"unassigned",
"primary",
"term",
":",
"\"",
"expected",
"an",
"assigned",
"primary",
"term",
"\"",
";",
"final",
"update",
"request",
"builder",
"update",
"request",
"=",
"client",
"prepare",
"update",
"(",
"refreshed",
"token",
"index",
"alias",
"name",
"(",
")",
",",
"token",
"doc",
"id",
")",
"set",
"doc",
"(",
"\"",
"refresh",
"token",
"\"",
",",
"update",
"map",
")",
"set",
"fetch",
"source",
"(",
"true",
")",
"set",
"refresh",
"policy",
"(",
"refresh",
"policy",
"immediate",
")",
"set",
"if",
"seq",
"no",
"(",
"seq",
"no",
")",
"set",
"if",
"primary",
"term",
"(",
"primary",
"term",
")",
";",
"refreshed",
"token",
"index",
"prepare",
"index",
"if",
"needed",
"then",
"execute",
"(",
"ex",
"-",
">",
"listener",
"on",
"failure",
"(",
"trace",
"log",
"(",
"\"",
"prepare",
"index",
"[",
"\"",
"+",
"refreshed",
"token",
"index",
"alias",
"name",
"(",
")",
"+",
"\"",
"]",
"\"",
",",
"ex",
")",
")",
",",
"(",
")",
"-",
">",
"execute",
"async",
"with",
"origin",
"(",
"client",
"thread",
"pool",
"(",
")",
"get",
"thread",
"context",
"(",
")",
",",
"security",
"origin",
",",
"update",
"request",
"request",
"(",
")",
",",
"action",
"listener",
"<",
"update",
"response",
">",
"wrap",
"(",
"update",
"response",
"-",
">",
"{",
"if",
"(",
"update",
"response",
"get",
"result",
"(",
")",
"=",
"=",
"doc",
"write",
"response",
"result",
"updated",
")",
"{",
"logger",
"debug",
"(",
"(",
")",
"-",
">",
"new",
"parameterized",
"message",
"(",
"\"",
"updated",
"the",
"original",
"token",
"document",
"to",
"{",
"}",
"\"",
",",
"update",
"response",
"get",
"get",
"result",
"(",
")",
"source",
"as",
"map",
"(",
")",
")",
")",
";",
"final",
"tuple",
"<",
"user",
"token",
",",
"string",
">",
"parsed",
"tokens",
"=",
"parse",
"tokens",
"from",
"document",
"(",
"source",
",",
"null",
")",
";",
"final",
"user",
"token",
"to",
"refresh",
"user",
"token",
"=",
"parsed",
"tokens",
"v",
"1",
"(",
")",
";",
"create",
"o",
"auth",
"2",
"tokens",
"(",
"new",
"access",
"token",
"string",
",",
"new",
"refresh",
"token",
"string",
",",
"new",
"token",
"version",
",",
"get",
"tokens",
"index",
"for",
"version",
"(",
"new",
"token",
"version",
")",
",",
"to",
"refresh",
"user",
"token",
"get",
"authentication",
"(",
")",
",",
"client",
"auth",
",",
"to",
"refresh",
"user",
"token",
"get",
"metadata",
"(",
")",
",",
"listener",
")",
";",
"}",
"else",
"if",
"(",
"backoff",
"has",
"next",
"(",
")",
")",
"{",
"logger",
"info",
"(",
"\"",
"failed",
"to",
"update",
"the",
"original",
"token",
"document",
"[",
"{",
"}",
"]",
",",
"the",
"update",
"result",
"was",
"[",
"{",
"}",
"]",
"retrying",
"\"",
",",
"token",
"doc",
"id",
",",
"update",
"response",
"get",
"result",
"(",
")",
")",
";",
"client",
"thread",
"pool",
"(",
")",
"schedule",
"(",
"(",
")",
"-",
">",
"inner",
"refresh",
"(",
"refresh",
"token",
",",
"token",
"doc",
"id",
",",
"source",
",",
"seq",
"no",
",",
"primary",
"term",
",",
"client",
"auth",
",",
"backoff",
",",
"refresh",
"requested",
",",
"listener",
")",
",",
"backoff",
"next",
"(",
")",
",",
"generic",
")",
";",
"}",
"else",
"{",
"logger",
"info",
"(",
"\"",
"failed",
"to",
"update",
"the",
"original",
"token",
"document",
"[",
"{",
"}",
"]",
"after",
"all",
"retries",
",",
"the",
"update",
"result",
"was",
"[",
"{",
"}",
"]",
"\"",
",",
"token",
"doc",
"id",
",",
"update",
"response",
"get",
"result",
"(",
")",
")",
";",
"listener",
"on",
"failure",
"(",
"invalid",
"grant",
"exception",
"(",
"\"",
"could",
"not",
"refresh",
"the",
"requested",
"token",
"\"",
")",
")",
";",
"}",
"}",
",",
"e",
"-",
">",
"{",
"throwable",
"cause",
"=",
"exceptions",
"helper",
"unwrap",
"cause",
"(",
"e",
")",
";",
"if",
"(",
"cause",
"instanceof",
"version",
"conflict",
"engine",
"exception",
")",
"{",
"/",
"/",
"the",
"document",
"has",
"been",
"updated",
"by",
"another",
"thread",
",",
"get",
"it",
"again",
"logger",
"debug",
"(",
"\"",
"version",
"conflict",
"while",
"updating",
"document",
"[",
"{",
"}",
"]",
",",
"attempting",
"to",
"get",
"it",
"again",
"\"",
",",
"token",
"doc",
"id",
")",
";",
"get",
"token",
"doc",
"async",
"(",
"token",
"doc",
"id",
",",
"refreshed",
"token",
"index",
",",
"true",
",",
"new",
"action",
"listener",
"<",
"get",
"response",
">",
"(",
")",
"{",
"@",
"override",
"public",
"void",
"on",
"response",
"(",
"get",
"response",
"response",
")",
"{",
"if",
"(",
"response",
"is",
"exists",
"(",
")",
")",
"{",
"inner",
"refresh",
"(",
"refresh",
"token",
",",
"token",
"doc",
"id",
",",
"response",
"get",
"source",
"(",
")",
",",
"response",
"get",
"seq",
"no",
"(",
")",
",",
"response",
"get",
"primary",
"term",
"(",
")",
",",
"client",
"auth",
",",
"backoff",
",",
"refresh",
"requested",
",",
"listener",
")",
";",
"}",
"else",
"{",
"logger",
"warn",
"(",
"\"",
"could",
"not",
"find",
"token",
"document",
"[",
"{",
"}",
"]",
"for",
"refresh",
"\"",
",",
"token",
"doc",
"id",
")",
";",
"on",
"failure",
"accept",
"(",
"invalid",
"grant",
"exception",
"(",
"\"",
"could",
"not",
"refresh",
"the",
"requested",
"token",
"\"",
")",
")",
";",
"}",
"}",
"@",
"override",
"public",
"void",
"on",
"failure",
"(",
"exception",
"e",
")",
"{",
"if",
"(",
"is",
"shard",
"not",
"available",
"exception",
"(",
"e",
")",
")",
"{",
"if",
"(",
"backoff",
"has",
"next",
"(",
")",
")",
"{",
"logger",
"info",
"(",
"\"",
"could",
"not",
"get",
"token",
"document",
"[",
"{",
"}",
"]",
"for",
"refresh",
",",
"retrying",
"\"",
",",
"token",
"doc",
"id",
")",
";",
"client",
"thread",
"pool",
"(",
")",
"schedule",
"(",
"(",
")",
"-",
">",
"get",
"token",
"doc",
"async",
"(",
"token",
"doc",
"id",
",",
"refreshed",
"token",
"index",
",",
"true",
",",
"this",
")",
",",
"backoff",
"next",
"(",
")",
",",
"generic",
")",
";",
"}",
"else",
"{",
"logger",
"warn",
"(",
"\"",
"could",
"not",
"get",
"token",
"document",
"[",
"{",
"}",
"]",
"for",
"refresh",
"after",
"all",
"retries",
"\"",
",",
"token",
"doc",
"id",
")",
";",
"on",
"failure",
"accept",
"(",
"invalid",
"grant",
"exception",
"(",
"\"",
"could",
"not",
"refresh",
"the",
"requested",
"token",
"\"",
")",
")",
";",
"}",
"}",
"else",
"{",
"on",
"failure",
"accept",
"(",
"e",
")",
";",
"}",
"}",
"}",
")",
";",
"}",
"else",
"if",
"(",
"is",
"shard",
"not",
"available",
"exception",
"(",
"e",
")",
")",
"{",
"if",
"(",
"backoff",
"has",
"next",
"(",
")",
")",
"{",
"logger",
"debug",
"(",
"\"",
"failed",
"to",
"update",
"the",
"original",
"token",
"document",
"[",
"{",
"}",
"]",
",",
"retrying",
"\"",
",",
"token",
"doc",
"id",
")",
";",
"client",
"thread",
"pool",
"(",
")",
"schedule",
"(",
"(",
")",
"-",
">",
"inner",
"refresh",
"(",
"refresh",
"token",
",",
"token",
"doc",
"id",
",",
"source",
",",
"seq",
"no",
",",
"primary",
"term",
",",
"client",
"auth",
",",
"backoff",
",",
"refresh",
"requested",
",",
"listener",
")",
",",
"backoff",
"next",
"(",
")",
",",
"generic",
")",
";",
"}",
"else",
"{",
"logger",
"warn",
"(",
"\"",
"failed",
"to",
"update",
"the",
"original",
"token",
"document",
"[",
"{",
"}",
"]",
",",
"after",
"all",
"retries",
"\"",
",",
"token",
"doc",
"id",
")",
";",
"on",
"failure",
"accept",
"(",
"invalid",
"grant",
"exception",
"(",
"\"",
"could",
"not",
"refresh",
"the",
"requested",
"token",
"\"",
")",
")",
";",
"}",
"}",
"else",
"{",
"on",
"failure",
"accept",
"(",
"e",
")",
";",
"}",
"}",
")",
",",
"client",
":",
":",
"update",
")",
")",
";",
"}",
"}"
] |
[
"{",
"@",
"inherit",
"doc",
"}",
"the",
"default",
"implementation",
"does",
"nothing"
] |
[
"@",
"override",
"public",
"void",
"exit",
"value",
"expression",
"default",
"(",
"sql",
"base",
"parser",
"value",
"expression",
"default",
"context",
"ctx",
")",
"{",
"}"
] |
[
"returns",
"queue",
"size"
] |
[
"public",
"synchronized",
"int",
"size",
"(",
")",
"{",
"return",
"storage",
"movement",
"needed",
"size",
"(",
")",
";",
"}"
] |
[
"convenient",
"factory",
"method",
"for",
"use",
"in",
"the",
"callback",
"of",
"{",
"@",
"link",
"method",
"visitor",
"#",
"visit",
"method",
"insn",
"}"
] |
[
"public",
"static",
"method",
"invocation",
"site",
"create",
"(",
"int",
"opcode",
",",
"string",
"owner",
",",
"string",
"name",
",",
"string",
"descriptor",
",",
"boolean",
"is",
"interface",
")",
"{",
"return",
"builder",
"(",
")",
"set",
"invocation",
"kind",
"(",
"member",
"use",
"kind",
"from",
"value",
"(",
"opcode",
")",
")",
"set",
"method",
"(",
"method",
"key",
"create",
"(",
"class",
"name",
"create",
"(",
"owner",
")",
",",
"name",
",",
"descriptor",
")",
")",
"set",
"is",
"interface",
"(",
"is",
"interface",
")",
"build",
"(",
")",
";",
"}"
] |
[
"returns",
"incremental",
"of",
"files",
"that",
"were",
"snapshotted"
] |
[
"public",
"int",
"incremental",
"file",
"count",
"(",
")",
"{",
"return",
"incremental",
"file",
"count",
";",
"}"
] |
[
"returns",
"whether",
"the",
"jndi",
"dns",
"resolver",
"is",
"available",
"this",
"is",
"accomplished",
"by",
"looking",
"up",
"a",
"particular",
"class",
"it",
"is",
"believed",
"to",
"be",
"the",
"default",
"(",
"only",
"?",
")",
"dns",
"resolver",
"that",
"will",
"actually",
"be",
"used",
"it",
"is",
"provided",
"by",
"the",
"open",
"j",
"d",
"k",
",",
"but",
"unlikely",
"android",
"actual",
"resolution",
"will",
"be",
"done",
"by",
"using",
"a",
"service",
"provider",
"when",
"a",
"hostname",
"query",
"is",
"present",
",",
"so",
"the",
"{",
"@",
"code",
"dns",
"context",
"factory",
"}",
"may",
"not",
"actually",
"be",
"used",
"to",
"perform",
"the",
"query",
"this",
"is",
"believed",
"to",
"be",
"\"",
"okay",
"\""
] |
[
"private",
"static",
"throwable",
"init",
"jndi",
"(",
")",
"{",
"try",
"{",
"class",
"for",
"name",
"(",
"\"",
"javax",
"naming",
"directory",
"initial",
"dir",
"context",
"\"",
")",
";",
"class",
"for",
"name",
"(",
"\"",
"com",
"sun",
"jndi",
"dns",
"dns",
"context",
"factory",
"\"",
")",
";",
"}",
"catch",
"(",
"class",
"not",
"found",
"exception",
"e",
")",
"{",
"return",
"e",
";",
"}",
"catch",
"(",
"runtime",
"exception",
"e",
")",
"{",
"return",
"e",
";",
"}",
"catch",
"(",
"error",
"e",
")",
"{",
"return",
"e",
";",
"}",
"return",
"null",
";",
"}"
] |
[
"returns",
"the",
"size",
"of",
"the",
"list",
"of",
"methods"
] |
[
"public",
"int",
"get",
"list",
"size",
"(",
")",
"{",
"return",
"method",
"records",
"size",
"(",
")",
";",
"}"
] |
[
"\"",
"overrides",
"\"",
"the",
"static",
"method",
"in",
"{",
"@",
"link",
"managed",
"channel",
"builder",
"}"
] |
[
"public",
"static",
"alts",
"channel",
"builder",
"for",
"address",
"(",
"string",
"name",
",",
"int",
"port",
")",
"{",
"return",
"for",
"target",
"(",
"grpc",
"util",
"authority",
"from",
"host",
"and",
"port",
"(",
"name",
",",
"port",
")",
")",
";",
"}"
] |
[
"register",
"a",
"listener",
"that",
"will",
"be",
"called",
"when",
"this",
"model",
"is",
"unbound",
"from",
"a",
"view",
"the",
"listener",
"will",
"contribute",
"to",
"this",
"model",
"'",
"s",
"hash",
"code",
"state",
"per",
"the",
"{",
"@",
"link",
"com",
"airbnb",
"epoxy",
"epoxy",
"attribute",
"option",
"#",
"do",
"not",
"hash",
"}",
"rules",
"you",
"may",
"clear",
"the",
"listener",
"by",
"setting",
"a",
"null",
"value",
",",
"or",
"by",
"calling",
"{",
"@",
"link",
"#",
"reset",
"(",
")",
"}"
] |
[
"public",
"saved",
"state",
"view",
"model",
"on",
"unbind",
"(",
"on",
"model",
"unbound",
"listener",
"<",
"saved",
"state",
"view",
"model",
",",
"saved",
"state",
"view",
">",
"listener",
")",
"{",
"on",
"mutation",
"(",
")",
";",
"this",
"on",
"model",
"unbound",
"listener",
"epoxy",
"generated",
"model",
"=",
"listener",
";",
"return",
"this",
";",
"}"
] |
[
"test",
"that",
"orientation",
"parameter",
"correctly",
"parses"
] |
[
"public",
"void",
"test",
"orientation",
"parsing",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"document",
"mapper",
"mapper",
"=",
"create",
"document",
"mapper",
"(",
"field",
"mapping",
"(",
"b",
"-",
">",
"b",
"field",
"(",
"\"",
"type",
"\"",
",",
"\"",
"geo",
"shape",
"\"",
")",
"field",
"(",
"\"",
"orientation",
"\"",
",",
"\"",
"left",
"\"",
")",
")",
")",
";",
"mapper",
"field",
"mapper",
"=",
"mapper",
"mappers",
"(",
")",
"get",
"mapper",
"(",
"\"",
"field",
"\"",
")",
";",
"assert",
"that",
"(",
"field",
"mapper",
",",
"instance",
"of",
"(",
"geo",
"shape",
"field",
"mapper",
"class",
")",
")",
";",
"shape",
"builder",
"orientation",
"orientation",
"=",
"(",
"(",
"geo",
"shape",
"field",
"mapper",
")",
"field",
"mapper",
")",
"field",
"type",
"(",
")",
"orientation",
"(",
")",
";",
"assert",
"that",
"(",
"orientation",
",",
"equal",
"to",
"(",
"shape",
"builder",
"orientation",
"clockwise",
")",
")",
";",
"assert",
"that",
"(",
"orientation",
",",
"equal",
"to",
"(",
"shape",
"builder",
"orientation",
"left",
")",
")",
";",
"assert",
"that",
"(",
"orientation",
",",
"equal",
"to",
"(",
"shape",
"builder",
"orientation",
"cw",
")",
")",
";",
"/",
"/",
"explicit",
"right",
"orientation",
"test",
"mapper",
"=",
"create",
"document",
"mapper",
"(",
"field",
"mapping",
"(",
"b",
"-",
">",
"b",
"field",
"(",
"\"",
"type",
"\"",
",",
"\"",
"geo",
"shape",
"\"",
")",
"field",
"(",
"\"",
"orientation",
"\"",
",",
"\"",
"right",
"\"",
")",
")",
")",
";",
"field",
"mapper",
"=",
"mapper",
"mappers",
"(",
")",
"get",
"mapper",
"(",
"\"",
"field",
"\"",
")",
";",
"assert",
"that",
"(",
"field",
"mapper",
",",
"instance",
"of",
"(",
"geo",
"shape",
"field",
"mapper",
"class",
")",
")",
";",
"orientation",
"=",
"(",
"(",
"geo",
"shape",
"field",
"mapper",
")",
"field",
"mapper",
")",
"field",
"type",
"(",
")",
"orientation",
"(",
")",
";",
"assert",
"that",
"(",
"orientation",
",",
"equal",
"to",
"(",
"shape",
"builder",
"orientation",
"counter",
"clockwise",
")",
")",
";",
"assert",
"that",
"(",
"orientation",
",",
"equal",
"to",
"(",
"shape",
"builder",
"orientation",
"right",
")",
")",
";",
"assert",
"that",
"(",
"orientation",
",",
"equal",
"to",
"(",
"shape",
"builder",
"orientation",
"ccw",
")",
")",
";",
"}"
] |
[
"removes",
"a",
"set",
"of",
"rows",
"from",
"the",
"top",
"of",
"the",
"view"
] |
[
"public",
"void",
"remove",
"rows",
"from",
"top",
"(",
"int",
"count",
")",
"{",
"for",
"(",
"int",
"i",
"=",
"0",
";",
"i",
"<",
"count",
";",
"i",
"+",
"+",
")",
"{",
"if",
"(",
"!",
"messages",
"is",
"empty",
"(",
")",
")",
"{",
"messages",
"remove",
"(",
"0",
")",
";",
"dates",
"remove",
"(",
"0",
")",
";",
"levels",
"remove",
"(",
"0",
")",
";",
"times",
"remove",
"(",
"0",
")",
";",
"}",
"}",
"fire",
"table",
"data",
"changed",
"(",
")",
";",
"}"
] |
[
"returns",
"the",
"data",
"type",
"of",
"a",
"pointer",
"to",
"the",
"type",
"represented",
"by",
"descriptor"
] |
[
"public",
"static",
"data",
"type",
"get",
"pointer",
"type",
"(",
"string",
"descriptor",
",",
"data",
"type",
"manager",
"dt",
"manager",
")",
"{",
"int",
"last",
"bracket",
"=",
"descriptor",
"last",
"index",
"of",
"(",
"\"",
"[",
"\"",
")",
";",
"string",
"base",
"type",
"of",
"array",
"=",
"descriptor",
"substring",
"(",
"last",
"bracket",
"+",
"1",
",",
"last",
"bracket",
"+",
"2",
")",
";",
"data",
"type",
"base",
"type",
"=",
"null",
";",
"switch",
"(",
"base",
"type",
"of",
"array",
"char",
"at",
"(",
"0",
")",
")",
"{",
"case",
"base",
"type",
"byte",
":",
"base",
"type",
"=",
"array",
"methods",
"get",
"array",
"base",
"type",
"(",
"java",
"class",
"constants",
"t",
"byte",
",",
"dt",
"manager",
")",
";",
"break",
";",
"case",
"base",
"type",
"boolean",
":",
"base",
"type",
"=",
"array",
"methods",
"get",
"array",
"base",
"type",
"(",
"java",
"class",
"constants",
"t",
"boolean",
",",
"dt",
"manager",
")",
";",
"break",
";",
"case",
"base",
"type",
"char",
":",
"base",
"type",
"=",
"array",
"methods",
"get",
"array",
"base",
"type",
"(",
"java",
"class",
"constants",
"t",
"char",
",",
"dt",
"manager",
")",
";",
"break",
";",
"case",
"base",
"type",
"double",
":",
"base",
"type",
"=",
"array",
"methods",
"get",
"array",
"base",
"type",
"(",
"java",
"class",
"constants",
"t",
"double",
",",
"dt",
"manager",
")",
";",
"break",
";",
"case",
"base",
"type",
"float",
":",
"base",
"type",
"=",
"array",
"methods",
"get",
"array",
"base",
"type",
"(",
"java",
"class",
"constants",
"t",
"float",
",",
"dt",
"manager",
")",
";",
"break",
";",
"case",
"base",
"type",
"int",
":",
"base",
"type",
"=",
"array",
"methods",
"get",
"array",
"base",
"type",
"(",
"java",
"class",
"constants",
"t",
"int",
",",
"dt",
"manager",
")",
";",
"break",
";",
"case",
"base",
"type",
"long",
":",
"base",
"type",
"=",
"array",
"methods",
"get",
"array",
"base",
"type",
"(",
"java",
"class",
"constants",
"t",
"long",
",",
"dt",
"manager",
")",
";",
"break",
";",
"case",
"base",
"type",
"short",
":",
"base",
"type",
"=",
"array",
"methods",
"get",
"array",
"base",
"type",
"(",
"java",
"class",
"constants",
"t",
"short",
",",
"dt",
"manager",
")",
";",
"break",
";",
"case",
"base",
"type",
"reference",
":",
"return",
"dt",
"manager",
"get",
"pointer",
"(",
"d",
"word",
"data",
"type",
"data",
"type",
")",
";",
"default",
":",
"throw",
"new",
"illegal",
"argument",
"exception",
"(",
"\"",
"invalid",
"array",
"base",
"type",
"category",
":",
"\"",
"+",
"base",
"type",
"of",
"array",
")",
";",
"}",
"return",
"dt",
"manager",
"get",
"pointer",
"(",
"base",
"type",
")",
";",
"}"
] |
[
"get",
"the",
"is",
"directory",
"value"
] |
[
"public",
"boolean",
"is",
"directory",
"(",
")",
"{",
"return",
"is",
"directory",
";",
"}"
] |
[
"return",
"the",
"number",
"of",
"indices",
"that",
"use",
"this",
"feature",
"across",
"the",
"cluster"
] |
[
"public",
"int",
"get",
"index",
"count",
"(",
")",
"{",
"return",
"index",
"count",
";",
"}"
] |
[
"assert",
"that",
"the",
"given",
"component",
"has",
"the",
"exact",
"text",
"provided"
] |
[
"public",
"component",
"assert",
"has",
"visible",
"text",
"(",
"string",
"text",
")",
"{",
"assert",
"that",
"litho",
"view",
"(",
")",
"has",
"visible",
"text",
"(",
"text",
")",
";",
"return",
"this",
";",
"}"
] |
[
"prints",
"custom",
"cli",
"options"
] |
[
"private",
"static",
"void",
"print",
"custom",
"cli",
"options",
"(",
"collection",
"<",
"custom",
"command",
"line",
">",
"custom",
"command",
"lines",
",",
"help",
"formatter",
"formatter",
",",
"boolean",
"run",
"options",
")",
"{",
"/",
"/",
"prints",
"options",
"from",
"all",
"available",
"command",
"-",
"line",
"classes",
"for",
"(",
"custom",
"command",
"line",
"cli",
":",
"custom",
"command",
"lines",
")",
"{",
"formatter",
"set",
"syntax",
"prefix",
"(",
"\"",
"options",
"for",
"\"",
"+",
"cli",
"get",
"id",
"(",
")",
"+",
"\"",
"mode",
":",
"\"",
")",
";",
"options",
"custom",
"opts",
"=",
"new",
"options",
"(",
")",
";",
"cli",
"add",
"general",
"options",
"(",
"custom",
"opts",
")",
";",
"if",
"(",
"run",
"options",
")",
"{",
"cli",
"add",
"run",
"options",
"(",
"custom",
"opts",
")",
";",
"}",
"formatter",
"print",
"help",
"(",
"\"",
"\"",
",",
"custom",
"opts",
")",
";",
"system",
"out",
"println",
"(",
")",
";",
"}",
"}"
] |
[
"keep",
"-",
"alive",
"interval",
"(",
"seconds",
")",
"zero",
"or",
"negative",
"means",
"no",
"keep",
"-",
"alive"
] |
[
"public",
"int",
"get",
"keep",
"alive",
"interval",
"(",
")",
"{",
"return",
"keep",
"alive",
"interval",
";",
"}"
] |
[
"tests",
"reading",
"an",
"zero",
"value",
"that",
"is",
"encoded",
"in",
"non",
"-",
"optimal",
"way"
] |
[
"public",
"void",
"test",
"alt",
"zero",
"encoded",
"(",
")",
"throws",
"i",
"o",
"exception",
"{",
"byte",
"[",
"]",
"bytes",
"=",
"new",
"byte",
"[",
"]",
"{",
"(",
"byte",
")",
"0x",
"8",
"0",
",",
"(",
"byte",
")",
"0x",
"8",
"0",
",",
"(",
"byte",
")",
"0x",
"8",
"0",
",",
"(",
"byte",
")",
"0x",
"8",
"0",
",",
"(",
"byte",
")",
"0x",
"8",
"0",
",",
"(",
"byte",
")",
"0x",
"0",
"}",
";",
"long",
"value",
"=",
"leb128",
"decode",
"(",
"bytes",
",",
"false",
")",
";",
"assert",
"assert",
"equals",
"(",
"0",
",",
"value",
")",
";",
"}"
] |
[
"ensures",
"the",
"json",
"field",
"names",
"begins",
"with",
"an",
"upper",
"case",
"letter"
] |
[
"static",
"string",
"upper",
"case",
"first",
"letter",
"(",
"string",
"name",
")",
"{",
"int",
"first",
"letter",
"index",
"=",
"0",
";",
"int",
"limit",
"=",
"name",
"length",
"(",
")",
"-",
"1",
";",
"for",
"(",
";",
"!",
"character",
"is",
"letter",
"(",
"name",
"char",
"at",
"(",
"first",
"letter",
"index",
")",
")",
"&",
"&",
"first",
"letter",
"index",
"<",
"limit",
";",
"+",
"+",
"first",
"letter",
"index",
")",
";",
"char",
"first",
"letter",
"=",
"name",
"char",
"at",
"(",
"first",
"letter",
"index",
")",
";",
"if",
"(",
"character",
"is",
"upper",
"case",
"(",
"first",
"letter",
")",
")",
"{",
"/",
"/",
"the",
"letter",
"is",
"already",
"uppercased",
",",
"return",
"the",
"original",
"return",
"name",
";",
"}",
"char",
"uppercased",
"=",
"character",
"to",
"upper",
"case",
"(",
"first",
"letter",
")",
";",
"if",
"(",
"first",
"letter",
"index",
"=",
"=",
"0",
")",
"{",
"/",
"/",
"first",
"character",
"in",
"the",
"string",
"is",
"the",
"first",
"letter",
",",
"saves",
"1",
"substring",
"return",
"uppercased",
"+",
"name",
"substring",
"(",
"1",
")",
";",
"}",
"return",
"name",
"substring",
"(",
"0",
",",
"first",
"letter",
"index",
")",
"+",
"uppercased",
"+",
"name",
"substring",
"(",
"first",
"letter",
"index",
"+",
"1",
")",
";",
"}"
] |
[
"get",
"the",
"string",
"representation",
"for",
"this",
"transferable"
] |
[
"public",
"string",
"to",
"string",
"(",
")",
"{",
"return",
"\"",
"tree",
"transferable",
"\"",
";",
"}"
] |
[
"get",
"name",
"string"
] |
[
"public",
"string",
"get",
"name",
"string",
"(",
")",
"{",
"return",
"name",
"string",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"client",
"'"
] |
[
"public",
"void",
"client",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"client",
"}"
] |
[
"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",
"\"",
")",
";",
"}"
] |
[
"adds",
"the",
"deprecated",
"key",
"to",
"the",
"global",
"deprecation",
"map",
"it",
"does",
"not",
"override",
"any",
"existing",
"entries",
"in",
"the",
"deprecation",
"map",
"this",
"is",
"to",
"be",
"used",
"only",
"by",
"the",
"developers",
"in",
"order",
"to",
"add",
"deprecation",
"of",
"keys",
",",
"and",
"attempts",
"to",
"call",
"this",
"method",
"after",
"loading",
"resources",
"once",
",",
"would",
"lead",
"to",
"<",
"tt",
">",
"unsupported",
"operation",
"exception",
"<",
"tt",
">",
"if",
"you",
"have",
"multiple",
"deprecation",
"entries",
"to",
"add",
",",
"it",
"is",
"more",
"efficient",
"to",
"use",
"#",
"add",
"deprecations",
"(",
"deprecation",
"delta",
"[",
"]",
"deltas",
")",
"instead"
] |
[
"public",
"static",
"void",
"add",
"deprecation",
"(",
"string",
"key",
",",
"string",
"new",
"key",
",",
"string",
"custom",
"message",
")",
"{",
"add",
"deprecation",
"(",
"key",
",",
"new",
"string",
"[",
"]",
"{",
"new",
"key",
"}",
",",
"custom",
"message",
")",
";",
"}"
] |
[
"model",
"tests",
"for",
"order"
] |
[
"public",
"void",
"test",
"order",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"order",
"}"
] |
[
"the",
"tls",
"version",
"is",
"present",
"in",
"ok",
"http",
"3",
"0",
"and",
"beyond"
] |
[
"@",
"test",
"public",
"void",
"test",
"golden",
"cache",
"https",
"response",
"ok",
"http",
"3",
"0",
"(",
")",
"throws",
"exception",
"{",
"http",
"url",
"url",
"=",
"server",
"url",
"(",
"\"",
"/",
"\"",
")",
";",
"string",
"url",
"key",
"=",
"cache",
"key",
"(",
"url",
")",
";",
"string",
"prefix",
"=",
"platform",
"get",
"(",
")",
"get",
"prefix",
"(",
")",
";",
"string",
"entry",
"metadata",
"=",
"\"",
"\"",
"+",
"\"",
"\"",
"+",
"url",
"+",
"\"",
"\\",
"n",
"\"",
"+",
"\"",
"get",
"\\",
"n",
"\"",
"+",
"\"",
"0",
"\\",
"n",
"\"",
"+",
"\"",
"http",
"/",
"1",
"1",
"200",
"ok",
"\\",
"n",
"\"",
"+",
"\"",
"4",
"\\",
"n",
"\"",
"+",
"\"",
"content",
"-",
"length",
":",
"3",
"\\",
"n",
"\"",
"+",
"prefix",
"+",
"\"",
"-",
"received",
"-",
"millis",
":",
"\"",
"+",
"system",
"current",
"time",
"millis",
"(",
")",
"+",
"\"",
"\\",
"n",
"\"",
"+",
"prefix",
"+",
"\"",
"-",
"sent",
"-",
"millis",
":",
"\"",
"+",
"system",
"current",
"time",
"millis",
"(",
")",
"+",
"\"",
"\\",
"n",
"\"",
"+",
"\"",
"cache",
"-",
"control",
":",
"max",
"-",
"age",
"=",
"60",
"\\",
"n",
"\"",
"+",
"\"",
"\\",
"n",
"\"",
"+",
"\"",
"tls",
"ecdhe",
"rsa",
"with",
"aes",
"128",
"gcm",
"sha256",
"\\",
"n",
"\"",
"+",
"\"",
"1",
"\\",
"n",
"\"",
"+",
"\"",
"m",
"i",
"i",
"bn",
"d",
"c",
"c",
"a",
"q",
"wg",
"aw",
"i",
"b",
"ag",
"i",
"b",
"a",
"t",
"a",
"n",
"bgkqhki",
"g",
"9w",
"0",
"b",
"a",
"qs",
"f",
"a",
"d",
"a",
"u",
"m",
"r",
"iw",
"e",
"a",
"y",
"d",
"v",
"q",
"q",
"d",
"ewlsb",
"2",
"nhb",
"ghvc",
"3",
"qw",
"hhc",
"n",
"m",
"t",
"ux",
"mj",
"iy",
"m",
"d",
"ex",
"\"",
"+",
"\"",
"m",
"t",
"qw",
"whc",
"n",
"m",
"t",
"ux",
"mj",
"iz",
"m",
"d",
"ex",
"m",
"t",
"qw",
"wj",
"a",
"u",
"m",
"r",
"iw",
"e",
"a",
"y",
"d",
"v",
"q",
"q",
"d",
"ewlsb",
"2",
"nhb",
"ghvc",
"3",
"qwg",
"z",
"8w",
"d",
"q",
"y",
"j",
"ko",
"z",
"ihvc",
"n",
"a",
"q",
"e",
"b",
"b",
"q",
"a",
"dg",
"y",
"0",
"a",
"m",
"i",
"g",
"j",
"\"",
"+",
"\"",
"ao",
"g",
"b",
"a",
"j",
"tn",
"2",
"dh",
"8x",
"ymegvp",
"o",
"sms",
"kb",
"2",
"os",
"6",
"cxf",
"1",
"l",
"4f",
"ybn",
"hr",
"/",
"tur",
"in",
"u",
"d",
"5r",
"1",
"p",
"7",
"z",
"auxur",
"y",
"8",
"8",
"0q",
"3",
"g",
"t",
"5b",
"u",
"doir",
"s",
"3",
"ifucddr",
"t",
"1",
"ac",
"\"",
"+",
"\"",
"am",
"uz",
"emk",
"/",
"f",
"djggi",
"p",
"8",
"dlx",
"fk",
"y",
"/",
"xw",
"x",
"blh",
"r",
"d",
"v",
"ip",
"/",
"m",
"ru",
"a",
"s",
"p",
"m",
"g",
"inckc",
"0",
"zaix",
"ok",
"r",
"fyrx",
"a",
"dj",
"+",
"r",
"1ea",
"sm",
"x",
"c",
"iv",
"v",
"5y",
"t",
"y",
"6",
"ia",
"iok",
"lj",
"1",
"\"",
"+",
"\"",
"ag",
"m",
"b",
"a",
"a",
"ew",
"d",
"q",
"y",
"j",
"ko",
"z",
"ihvc",
"n",
"a",
"q",
"e",
"l",
"b",
"q",
"a",
"dg",
"y",
"e",
"a",
"fblnedqtf",
"rq",
"i",
"9j",
"2",
"w",
"dy",
"p",
"po",
"g",
"0",
"n",
"t",
"zf",
"9xwje",
"uu",
"+",
"ju",
"+",
"ktty",
"8u",
"9k",
"7",
"lgrrd",
"/",
"dh2",
"\"",
"+",
"\"",
"m",
"q",
"et",
"b",
"d",
"1",
"ctvp",
"9",
"1",
"m",
"jf",
"a",
"cl",
"ng",
"3fa",
"zzw",
"cl",
"uyu",
"5pd",
"0",
"q",
"x",
"r",
"z",
"e",
"uw",
"sw",
"z",
"q",
"nen",
"2",
"q",
"w",
"d",
"h",
"rl",
"vs",
"itcl",
"b",
"j",
"4t",
"+",
"a",
"j",
"lq",
"tbwof",
"wi",
"4m",
"4",
"k",
"8",
"r",
"e",
"ol",
"\"",
"+",
"\"",
"5",
"9",
"3h",
"d",
"5",
"5",
"e",
"4",
"+",
"l",
"y",
"2",
"2",
"j",
"zi",
"v",
"qyjs",
"qhe",
"6",
"i",
"=",
"\\",
"n",
"\"",
"+",
"\"",
"0",
"\\",
"n",
"\"",
"+",
"\"",
"t",
"l",
"sv",
"1",
"2",
"\\",
"n",
"\"",
";",
"string",
"entry",
"body",
"=",
"\"",
"abc",
"\"",
";",
"string",
"journal",
"body",
"=",
"\"",
"\"",
"+",
"\"",
"libcore",
"io",
"disk",
"lru",
"cache",
"\\",
"n",
"\"",
"+",
"\"",
"1",
"\\",
"n",
"\"",
"+",
"\"",
"201105",
"\\",
"n",
"\"",
"+",
"\"",
"2",
"\\",
"n",
"\"",
"+",
"\"",
"\\",
"n",
"\"",
"+",
"\"",
"dirty",
"\"",
"+",
"url",
"key",
"+",
"\"",
"\\",
"n",
"\"",
"+",
"\"",
"clean",
"\"",
"+",
"url",
"key",
"+",
"\"",
"\"",
"+",
"entry",
"metadata",
"length",
"(",
")",
"+",
"\"",
"\"",
"+",
"entry",
"body",
"length",
"(",
")",
"+",
"\"",
"\\",
"n",
"\"",
";",
"write",
"file",
"(",
"cache",
"directory",
"(",
")",
",",
"url",
"key",
"+",
"\"",
"0",
"\"",
",",
"entry",
"metadata",
")",
";",
"write",
"file",
"(",
"cache",
"directory",
"(",
")",
",",
"url",
"key",
"+",
"\"",
"1",
"\"",
",",
"entry",
"body",
")",
";",
"write",
"file",
"(",
"cache",
"directory",
"(",
")",
",",
"\"",
"journal",
"\"",
",",
"journal",
"body",
")",
";",
"cache",
"close",
"(",
")",
";",
"cache",
"=",
"new",
"cache",
"(",
"cache",
"directory",
"(",
")",
",",
"integer",
"max",
"value",
",",
"file",
"system",
")",
";",
"client",
"=",
"client",
"new",
"builder",
"(",
")",
"cache",
"(",
"cache",
")",
"build",
"(",
")",
";",
"response",
"response",
"=",
"get",
"(",
"url",
")",
";",
"assert",
"that",
"(",
"response",
"body",
"(",
")",
"string",
"(",
")",
")",
"is",
"equal",
"to",
"(",
"entry",
"body",
")",
";",
"assert",
"that",
"(",
"response",
"header",
"(",
"\"",
"content",
"-",
"length",
"\"",
")",
")",
"is",
"equal",
"to",
"(",
"\"",
"3",
"\"",
")",
";",
"}"
] |
[
"test",
"the",
"property",
"'",
"class",
"name",
"'"
] |
[
"public",
"void",
"class",
"name",
"test",
"(",
")",
"{",
"/",
"/",
"todo",
":",
"test",
"class",
"name",
"}"
] |
[
"returns",
"the",
"key",
"for",
"the",
"specified",
"value",
",",
"or",
"not",
"found",
"if",
"it",
"is",
"not",
"in",
"the",
"map",
"note",
"this",
"traverses",
"the",
"entire",
"map",
"and",
"compares",
"every",
"value",
",",
"which",
"may",
"be",
"an",
"expensive",
"operation"
] |
[
"public",
"int",
"find",
"key",
"(",
"float",
"value",
",",
"int",
"not",
"found",
")",
"{",
"if",
"(",
"has",
"zero",
"value",
"&",
"&",
"zero",
"value",
"=",
"=",
"value",
")",
"return",
"0",
";",
"int",
"[",
"]",
"key",
"table",
"=",
"this",
"key",
"table",
";",
"float",
"[",
"]",
"value",
"table",
"=",
"this",
"value",
"table",
";",
"for",
"(",
"int",
"i",
"=",
"value",
"table",
"length",
"-",
"1",
";",
"i",
">",
"=",
"0",
";",
"i",
"-",
"-",
")",
"if",
"(",
"key",
"table",
"[",
"i",
"]",
"!",
"=",
"0",
"&",
"&",
"value",
"table",
"[",
"i",
"]",
"=",
"=",
"value",
")",
"return",
"key",
"table",
"[",
"i",
"]",
";",
"return",
"not",
"found",
";",
"}"
] |
[
"some",
"file",
"systems",
"like",
"local",
"file",
"system",
"have",
"an",
"initial",
"working",
"dir",
"that",
"is",
"used",
"as",
"the",
"starting",
"working",
"dir",
"for",
"other",
"file",
"systems",
"like",
"hdfs",
"there",
"is",
"no",
"built",
"in",
"notion",
"of",
"an",
"initial",
"working",
"dir"
] |
[
"public",
"path",
"get",
"initial",
"working",
"directory",
"(",
")",
"{",
"return",
"null",
";",
"}"
] |
[
"sets",
"a",
"new",
"max",
"container",
"recursive",
"depth",
"limit",
"for",
"this",
"batch",
"import",
"doing",
"this",
"requires",
"rescanning",
"all",
"original",
"user",
"-",
"added",
"source",
"files",
"and",
"stopping",
"at",
"the",
"new",
"max",
"depth"
] |
[
"public",
"void",
"set",
"max",
"depth",
"(",
"int",
"new",
"max",
"depth",
")",
"{",
"/",
"/",
"@",
"formatter",
":",
"off",
"new",
"task",
"builder",
"(",
"\"",
"scanning",
"source",
"files",
"\"",
",",
"monitor",
"-",
">",
"do",
"set",
"max",
"depth",
"(",
"new",
"max",
"depth",
",",
"monitor",
")",
")",
"set",
"status",
"text",
"alignment",
"(",
"swing",
"constants",
"leading",
")",
"set",
"has",
"progress",
"(",
"false",
")",
"/",
"/",
"indeterminate",
"launch",
"modal",
"(",
")",
";",
"/",
"/",
"@",
"formatter",
":",
"on",
"}"
] |
[
"this",
"methods",
"sends",
"the",
"specified",
"allocate",
"requests",
"to",
"the",
"appropriate",
"sub",
"-",
"cluster",
"resource",
"managers",
"asynchronously"
] |
[
"private",
"void",
"send",
"requests",
"to",
"resource",
"managers",
"(",
"map",
"<",
"sub",
"cluster",
"id",
",",
"allocate",
"request",
">",
"requests",
")",
"throws",
"yarn",
"exception",
",",
"i",
"o",
"exception",
"{",
"/",
"/",
"create",
"new",
"uam",
"instances",
"for",
"the",
"sub",
"-",
"cluster",
"that",
"we",
"haven",
"'",
"t",
"seen",
"before",
"list",
"<",
"sub",
"cluster",
"id",
">",
"new",
"sub",
"clusters",
"=",
"register",
"and",
"allocate",
"with",
"new",
"sub",
"clusters",
"(",
"requests",
")",
";",
"/",
"/",
"now",
"that",
"all",
"the",
"registrations",
"are",
"done",
",",
"send",
"the",
"allocation",
"request",
"/",
"/",
"to",
"the",
"sub",
"-",
"cluster",
"r",
"ms",
"asynchronously",
"and",
"don",
"'",
"t",
"wait",
"for",
"the",
"response",
"/",
"/",
"the",
"responses",
"will",
"arrive",
"asynchronously",
"and",
"will",
"be",
"added",
"to",
"the",
"/",
"/",
"response",
"sink",
",",
"then",
"merged",
"and",
"sent",
"to",
"the",
"application",
"master",
"for",
"(",
"entry",
"<",
"sub",
"cluster",
"id",
",",
"allocate",
"request",
">",
"entry",
":",
"requests",
"entry",
"set",
"(",
")",
")",
"{",
"sub",
"cluster",
"id",
"sub",
"cluster",
"id",
"=",
"entry",
"get",
"key",
"(",
")",
";",
"if",
"(",
"new",
"sub",
"clusters",
"contains",
"(",
"sub",
"cluster",
"id",
")",
")",
"{",
"/",
"/",
"for",
"new",
"sub",
"-",
"clusters",
",",
"we",
"have",
"already",
"sent",
"the",
"request",
"right",
"after",
"/",
"/",
"register",
"in",
"the",
"async",
"thread",
"continue",
";",
"}",
"if",
"(",
"sub",
"cluster",
"id",
"equals",
"(",
"this",
"home",
"sub",
"cluster",
"id",
")",
")",
"{",
"/",
"/",
"request",
"for",
"the",
"home",
"sub",
"-",
"cluster",
"resource",
"manager",
"this",
"home",
"heartbeart",
"handler",
"allocate",
"async",
"(",
"entry",
"get",
"value",
"(",
")",
",",
"new",
"heartbeat",
"call",
"back",
"(",
"this",
"home",
"sub",
"cluster",
"id",
",",
"false",
")",
")",
";",
"}",
"else",
"{",
"if",
"(",
"!",
"this",
"uam",
"pool",
"has",
"u",
"a",
"m",
"id",
"(",
"sub",
"cluster",
"id",
"get",
"id",
"(",
")",
")",
")",
"{",
"throw",
"new",
"yarn",
"exception",
"(",
"\"",
"uam",
"not",
"found",
"for",
"\"",
"+",
"this",
"attempt",
"id",
"+",
"\"",
"in",
"sub",
"-",
"cluster",
"\"",
"+",
"sub",
"cluster",
"id",
")",
";",
"}",
"this",
"uam",
"pool",
"allocate",
"async",
"(",
"sub",
"cluster",
"id",
"get",
"id",
"(",
")",
",",
"entry",
"get",
"value",
"(",
")",
",",
"new",
"heartbeat",
"call",
"back",
"(",
"sub",
"cluster",
"id",
",",
"true",
")",
")",
";",
"}",
"}",
"}"
] |
[
"choose",
"local",
"node",
"of",
"local",
"machine",
"as",
"the",
"target",
"if",
"local",
"machine",
"is",
"not",
"available",
",",
"will",
"fallback",
"to",
"nodegrouprack",
"when",
"flag",
"fallback",
"to",
"node",
"group",
"and",
"local",
"rack",
"is",
"set"
] |
[
"protected",
"datanode",
"storage",
"info",
"choose",
"local",
"storage",
"(",
"node",
"local",
"machine",
",",
"set",
"<",
"node",
">",
"excluded",
"nodes",
",",
"long",
"blocksize",
",",
"int",
"max",
"nodes",
"per",
"rack",
",",
"list",
"<",
"datanode",
"storage",
"info",
">",
"results",
",",
"boolean",
"avoid",
"stale",
"nodes",
",",
"enum",
"map",
"<",
"storage",
"type",
",",
"integer",
">",
"storage",
"types",
",",
"boolean",
"fallback",
"to",
"node",
"group",
"and",
"local",
"rack",
")",
"throws",
"not",
"enough",
"replicas",
"exception",
"{",
"datanode",
"storage",
"info",
"local",
"storage",
"=",
"choose",
"local",
"storage",
"(",
"local",
"machine",
",",
"excluded",
"nodes",
",",
"blocksize",
",",
"max",
"nodes",
"per",
"rack",
",",
"results",
",",
"avoid",
"stale",
"nodes",
",",
"storage",
"types",
")",
";",
"if",
"(",
"local",
"storage",
"!",
"=",
"null",
")",
"{",
"return",
"local",
"storage",
";",
"}",
"if",
"(",
"!",
"fallback",
"to",
"node",
"group",
"and",
"local",
"rack",
")",
"{",
"return",
"null",
";",
"}",
"/",
"/",
"try",
"a",
"node",
"on",
"local",
"node",
"group",
"datanode",
"storage",
"info",
"chosen",
"storage",
"=",
"choose",
"local",
"node",
"group",
"(",
"(",
"network",
"topology",
"with",
"node",
"group",
")",
"cluster",
"map",
",",
"local",
"machine",
",",
"excluded",
"nodes",
",",
"blocksize",
",",
"max",
"nodes",
"per",
"rack",
",",
"results",
",",
"avoid",
"stale",
"nodes",
",",
"storage",
"types",
")",
";",
"if",
"(",
"chosen",
"storage",
"!",
"=",
"null",
")",
"{",
"return",
"chosen",
"storage",
";",
"}",
"/",
"/",
"try",
"a",
"node",
"on",
"local",
"rack",
"return",
"choose",
"local",
"rack",
"(",
"local",
"machine",
",",
"excluded",
"nodes",
",",
"blocksize",
",",
"max",
"nodes",
"per",
"rack",
",",
"results",
",",
"avoid",
"stale",
"nodes",
",",
"storage",
"types",
")",
";",
"}"
] |
[
"called",
"when",
"user",
"hits",
"the",
"cancel",
"button"
] |
[
"protected",
"void",
"cancel",
"callback",
"(",
")",
"{",
"cancelled",
"=",
"true",
";",
"close",
"(",
")",
";",
"}"
] |
[
"check",
"if",
"a",
"block",
"is",
"valid"
] |
[
"public",
"void",
"check",
"block",
"(",
"extended",
"block",
"b",
",",
"long",
"min",
"length",
",",
"replica",
"state",
"state",
")",
"throws",
"replica",
"not",
"found",
"exception",
",",
"unexpected",
"replica",
"state",
"exception",
"{",
"final",
"b",
"info",
"binfo",
"=",
"get",
"b",
"info",
"(",
"b",
")",
";",
"if",
"(",
"binfo",
"=",
"=",
"null",
")",
"{",
"throw",
"new",
"replica",
"not",
"found",
"exception",
"(",
"b",
")",
";",
"}",
"if",
"(",
"(",
"state",
"=",
"=",
"replica",
"state",
"finalized",
"&",
"&",
"!",
"binfo",
"is",
"finalized",
"(",
")",
")",
"|",
"|",
"(",
"state",
"!",
"=",
"replica",
"state",
"finalized",
"&",
"&",
"binfo",
"is",
"finalized",
"(",
")",
")",
")",
"{",
"throw",
"new",
"unexpected",
"replica",
"state",
"exception",
"(",
"b",
",",
"state",
")",
";",
"}",
"}"
] |
[
"convert",
"the",
"given",
"object",
"to",
"string",
"with",
"each",
"line",
"indented",
"by",
"4",
"spaces",
"(",
"except",
"the",
"first",
"line",
")"
] |
[
"private",
"static",
"string",
"to",
"indented",
"string",
"(",
"object",
"o",
")",
"{",
"if",
"(",
"o",
"=",
"=",
"null",
")",
"{",
"return",
"\"",
"null",
"\"",
";",
"}",
"return",
"o",
"to",
"string",
"(",
")",
"replace",
"(",
"\"",
"\\",
"n",
"\"",
",",
"\"",
"\\",
"n",
"\"",
")",
";",
"}"
] |
[
"gets",
"a",
"collection",
"of",
"iterator",
"settings",
"that",
"should",
"be",
"added",
"to",
"the",
"metric",
"table",
"for",
"the",
"given",
"accumulo",
"table",
"don",
"'",
"t",
"forget",
"!",
"please",
"!"
] |
[
"public",
"static",
"collection",
"<",
"iterator",
"setting",
">",
"get",
"metric",
"iterators",
"(",
"accumulo",
"table",
"table",
")",
"{",
"string",
"card",
"qualifier",
"=",
"new",
"string",
"(",
"cardinality",
"cq",
")",
";",
"string",
"rows",
"family",
"=",
"new",
"string",
"(",
"metrics",
"table",
"rows",
"cf",
"array",
"(",
")",
")",
";",
"/",
"/",
"build",
"a",
"string",
"for",
"all",
"columns",
"where",
"the",
"summing",
"combiner",
"should",
"be",
"applied",
",",
"/",
"/",
"i",
"e",
"all",
"indexed",
"columns",
"string",
"builder",
"card",
"builder",
"=",
"new",
"string",
"builder",
"(",
"rows",
"family",
"+",
"\"",
":",
"\"",
"+",
"card",
"qualifier",
"+",
"\"",
",",
"\"",
")",
";",
"for",
"(",
"string",
"s",
":",
"get",
"locality",
"groups",
"(",
"table",
")",
"key",
"set",
"(",
")",
")",
"{",
"card",
"builder",
"append",
"(",
"s",
")",
"append",
"(",
"\"",
":",
"\"",
")",
"append",
"(",
"card",
"qualifier",
")",
"append",
"(",
"'",
",",
"'",
")",
";",
"}",
"card",
"builder",
"delete",
"char",
"at",
"(",
"card",
"builder",
"length",
"(",
")",
"-",
"1",
")",
";",
"/",
"/",
"configuration",
"rows",
"for",
"the",
"min",
"/",
"max",
"combiners",
"string",
"first",
"row",
"column",
"=",
"rows",
"family",
"+",
"\"",
":",
"\"",
"+",
"new",
"string",
"(",
"metrics",
"table",
"first",
"row",
"cq",
"array",
"(",
")",
")",
";",
"string",
"last",
"row",
"column",
"=",
"rows",
"family",
"+",
"\"",
":",
"\"",
"+",
"new",
"string",
"(",
"metrics",
"table",
"last",
"row",
"cq",
"array",
"(",
")",
")",
";",
"/",
"/",
"summing",
"combiner",
"for",
"cardinality",
"columns",
"iterator",
"setting",
"s",
"1",
"=",
"new",
"iterator",
"setting",
"(",
"1",
",",
"summing",
"combiner",
"class",
",",
"immutable",
"map",
"of",
"(",
"\"",
"columns",
"\"",
",",
"card",
"builder",
"to",
"string",
"(",
")",
",",
"\"",
"type",
"\"",
",",
"\"",
"string",
"\"",
")",
")",
";",
"/",
"/",
"min",
"/",
"max",
"combiner",
"for",
"the",
"first",
"/",
"last",
"rows",
"of",
"the",
"table",
"iterator",
"setting",
"s",
"2",
"=",
"new",
"iterator",
"setting",
"(",
"2",
",",
"min",
"byte",
"array",
"combiner",
"class",
",",
"immutable",
"map",
"of",
"(",
"\"",
"columns",
"\"",
",",
"first",
"row",
"column",
")",
")",
";",
"iterator",
"setting",
"s",
"3",
"=",
"new",
"iterator",
"setting",
"(",
"3",
",",
"max",
"byte",
"array",
"combiner",
"class",
",",
"immutable",
"map",
"of",
"(",
"\"",
"columns",
"\"",
",",
"last",
"row",
"column",
")",
")",
";",
"return",
"immutable",
"list",
"of",
"(",
"s",
"1",
",",
"s",
"2",
",",
"s",
"3",
")",
";",
"}"
] |
[
"gets",
"get",
"client",
"role"
] |
[
"public",
"netty",
"pool",
"key",
"transaction",
"role",
"get",
"client",
"role",
"(",
")",
"{",
"return",
"client",
"role",
";",
"}"
] |
[
"expect",
"a",
"job",
"commit",
"operation",
"to",
"fail",
"with",
"a",
"specific",
"exception"
] |
[
"protected",
"static",
"<",
"e",
"extends",
"i",
"o",
"exception",
">",
"e",
"expect",
"job",
"commit",
"failure",
"(",
"job",
"context",
"j",
"context",
",",
"abstract",
"s",
"3",
"a",
"committer",
"committer",
",",
"class",
"<",
"e",
">",
"clazz",
")",
"throws",
"exception",
"{",
"return",
"intercept",
"(",
"clazz",
",",
"(",
")",
"-",
">",
"{",
"committer",
"commit",
"job",
"(",
"j",
"context",
")",
";",
"return",
"committer",
"to",
"string",
"(",
")",
";",
"}",
")",
";",
"}"
] |
[
"returns",
"the",
"first",
"region",
"id",
"or",
"null",
"for",
"{",
"@",
"link",
"#",
"us",
"standard",
"}"
] |
[
"public",
"string",
"get",
"first",
"region",
"id",
"(",
")",
"{",
"return",
"get",
"first",
"region",
"id",
"0",
"(",
")",
";",
"}"
] |
[
"wrap",
"the",
"supplied",
"{",
"@",
"link",
"statement",
"}",
"with",
"a",
"{",
"@",
"code",
"run",
"after",
"test",
"class",
"callbacks",
"}",
"statement"
] |
[
"private",
"statement",
"with",
"after",
"test",
"class",
"callbacks",
"(",
"statement",
"next",
",",
"test",
"context",
"manager",
"test",
"context",
"manager",
")",
"{",
"return",
"new",
"run",
"after",
"test",
"class",
"callbacks",
"(",
"next",
",",
"test",
"context",
"manager",
")",
";",
"}"
] |
[
"manually",
"shuts",
"down",
"the",
"driver"
] |
[
"public",
"void",
"close",
"driver",
"(",
")",
"throws",
"exception",
"{",
"if",
"(",
"this",
"driver",
"!",
"=",
"null",
")",
"{",
"this",
"driver",
"close",
"(",
")",
";",
"}",
"}"
] |
[
"this",
"method",
"works",
"by",
"exponentially",
"backing",
"off",
"as",
"more",
"records",
"are",
"present",
"in",
"the",
"stack",
"each",
"record",
"has",
"a",
"1",
"2",
"^",
"n",
"chance",
"of",
"dropping",
"the",
"top",
"most",
"record",
"and",
"replacing",
"it",
"with",
"itself",
"this",
"has",
"a",
"number",
"of",
"convenient",
"properties",
":",
"the",
"current",
"record",
"is",
"always",
"recorded",
"this",
"is",
"due",
"to",
"the",
"compare",
"and",
"swap",
"dropping",
"the",
"top",
"most",
"record",
",",
"rather",
"than",
"the",
"to",
"-",
"be",
"-",
"pushed",
"record",
"the",
"very",
"last",
"access",
"will",
"always",
"be",
"recorded",
"this",
"comes",
"as",
"a",
"property",
"of",
"1",
"it",
"is",
"possible",
"to",
"retain",
"more",
"records",
"than",
"the",
"target",
",",
"based",
"upon",
"the",
"probability",
"distribution",
"it",
"is",
"easy",
"to",
"keep",
"a",
"precise",
"record",
"of",
"the",
"number",
"of",
"elements",
"in",
"the",
"stack",
",",
"since",
"each",
"element",
"has",
"to",
"know",
"how",
"tall",
"the",
"stack",
"is",
"in",
"this",
"particular",
"implementation",
",",
"there",
"are",
"also",
"some",
"advantages",
"a",
"thread",
"local",
"random",
"is",
"used",
"to",
"decide",
"if",
"something",
"should",
"be",
"recorded",
"this",
"means",
"that",
"if",
"there",
"is",
"a",
"deterministic",
"access",
"pattern",
",",
"it",
"is",
"now",
"possible",
"to",
"see",
"what",
"other",
"accesses",
"occur",
",",
"rather",
"than",
"always",
"dropping",
"them",
"second",
",",
"after",
"{",
"@",
"link",
"#",
"target",
"records",
"}",
"accesses",
",",
"backoff",
"occurs",
"this",
"matches",
"typical",
"access",
"patterns",
",",
"where",
"there",
"are",
"either",
"a",
"high",
"number",
"of",
"accesses",
"(",
"i",
"e",
"a",
"cached",
"buffer",
")",
",",
"or",
"low",
"(",
"an",
"ephemeral",
"buffer",
")",
",",
"but",
"not",
"many",
"in",
"between",
"the",
"use",
"of",
"atomics",
"avoids",
"serializing",
"a",
"high",
"number",
"of",
"accesses",
",",
"when",
"most",
"of",
"the",
"records",
"will",
"be",
"thrown",
"away",
"high",
"contention",
"only",
"happens",
"when",
"there",
"are",
"very",
"few",
"existing",
"records",
",",
"which",
"is",
"only",
"likely",
"when",
"the",
"object",
"isn",
"'",
"t",
"shared",
"!",
"if",
"this",
"is",
"a",
"problem",
",",
"the",
"loop",
"can",
"be",
"aborted",
"and",
"the",
"record",
"dropped",
",",
"because",
"another",
"thread",
"won",
"the",
"race"
] |
[
"private",
"void",
"record",
"0",
"(",
"object",
"hint",
")",
"{",
"/",
"/",
"check",
"target",
"records",
">",
"0",
"here",
"to",
"avoid",
"similar",
"check",
"before",
"remove",
"from",
"and",
"add",
"to",
"last",
"records",
"if",
"(",
"target",
"records",
">",
"0",
")",
"{",
"trace",
"record",
"old",
"head",
";",
"trace",
"record",
"prev",
"head",
";",
"trace",
"record",
"new",
"head",
";",
"boolean",
"dropped",
";",
"do",
"{",
"if",
"(",
"(",
"prev",
"head",
"=",
"old",
"head",
"=",
"head",
"updater",
"get",
"(",
"this",
")",
")",
"=",
"=",
"null",
")",
"{",
"/",
"/",
"already",
"closed",
"return",
";",
"}",
"final",
"int",
"num",
"elements",
"=",
"old",
"head",
"pos",
"+",
"1",
";",
"if",
"(",
"num",
"elements",
">",
"=",
"target",
"records",
")",
"{",
"final",
"int",
"back",
"off",
"factor",
"=",
"math",
"min",
"(",
"num",
"elements",
"-",
"target",
"records",
",",
"30",
")",
";",
"if",
"(",
"dropped",
"=",
"platform",
"dependent",
"thread",
"local",
"random",
"(",
")",
"next",
"int",
"(",
"1",
"<",
"<",
"back",
"off",
"factor",
")",
"!",
"=",
"0",
")",
"{",
"prev",
"head",
"=",
"old",
"head",
"next",
";",
"}",
"}",
"else",
"{",
"dropped",
"=",
"false",
";",
"}",
"new",
"head",
"=",
"hint",
"!",
"=",
"null",
"?",
"new",
"trace",
"record",
"(",
"prev",
"head",
",",
"hint",
")",
":",
"new",
"trace",
"record",
"(",
"prev",
"head",
")",
";",
"}",
"while",
"(",
"!",
"head",
"updater",
"compare",
"and",
"set",
"(",
"this",
",",
"old",
"head",
",",
"new",
"head",
")",
")",
";",
"if",
"(",
"dropped",
")",
"{",
"dropped",
"records",
"updater",
"increment",
"and",
"get",
"(",
"this",
")",
";",
"}",
"}",
"}"
] |
[
"get",
"photo",
"urls"
] |
[
"public",
"set",
"<",
"string",
">",
"get",
"photo",
"urls",
"(",
")",
"{",
"return",
"photo",
"urls",
";",
"}"
] |
[
"get",
"the",
"{",
"@",
"link",
"sub",
"cluster",
"id",
"}",
"representing",
"the",
"unique",
"identifier",
"of",
"the",
"subcluster"
] |
[
"public",
"abstract",
"sub",
"cluster",
"id",
"get",
"sub",
"cluster",
"id",
"(",
")",
";"
] |
[
"sets",
"whether",
"this",
"timer",
"repeats"
] |
[
"public",
"synchronized",
"void",
"set",
"repeats",
"(",
"boolean",
"repeats",
")",
"{",
"this",
"repeats",
"=",
"repeats",
";",
"}"
] |
[
"gets",
"an",
"address",
"that",
"is",
"indicated",
"by",
"the",
"string"
] |
[
"public",
"address",
"addr",
"(",
"string",
"address",
")",
"{",
"return",
"mtf",
"get",
"result",
"program",
"(",
")",
"get",
"address",
"factory",
"(",
")",
"get",
"address",
"(",
"address",
")",
";",
"}"
] |
[
"this",
"method",
"looks",
"around",
"all",
"the",
"columns",
"in",
"the",
"table",
",",
"and",
"judge",
"which",
"of",
"them",
"are",
"foreign",
"key",
"columns"
] |
[
"protected",
"list",
"<",
"string",
">",
"get",
"foreign",
"key",
"columns",
"(",
"table",
"model",
"table",
"model",
")",
"{",
"list",
"<",
"string",
">",
"foreign",
"key",
"columns",
"=",
"new",
"array",
"list",
"<",
">",
"(",
")",
";",
"collection",
"<",
"column",
"model",
">",
"column",
"models",
"=",
"get",
"table",
"model",
"from",
"d",
"b",
"(",
"table",
"model",
"get",
"table",
"name",
"(",
")",
")",
"get",
"column",
"models",
"(",
")",
";",
"for",
"(",
"column",
"model",
"column",
"model",
":",
"column",
"models",
")",
"{",
"string",
"column",
"name",
"=",
"column",
"model",
"get",
"column",
"name",
"(",
")",
";",
"if",
"(",
"is",
"foreign",
"key",
"column",
"format",
"(",
"column",
"model",
"get",
"column",
"name",
"(",
")",
")",
")",
"{",
"if",
"(",
"!",
"table",
"model",
"contains",
"column",
"(",
"column",
"name",
")",
")",
"{",
"/",
"/",
"now",
"this",
"is",
"a",
"foreign",
"key",
"column",
"lite",
"pal",
"log",
"d",
"(",
"tag",
",",
"\"",
"get",
"foreign",
"key",
"column",
"names",
">",
">",
"foreign",
"key",
"column",
"is",
"\"",
"+",
"column",
"name",
")",
";",
"foreign",
"key",
"columns",
"add",
"(",
"column",
"name",
")",
";",
"}",
"}",
"}",
"return",
"foreign",
"key",
"columns",
";",
"}"
] |
[
"validates",
"if",
"a",
"given",
"type",
"is",
"not",
"already",
"contained",
"in",
"the",
"type",
"hierarchy",
"of",
"a",
"structured",
"type",
"otherwise",
"this",
"would",
"lead",
"to",
"infinite",
"data",
"type",
"extraction",
"cycles"
] |
[
"static",
"void",
"validate",
"structured",
"self",
"reference",
"(",
"type",
"t",
",",
"list",
"<",
"type",
">",
"type",
"hierarchy",
")",
"{",
"final",
"class",
"<",
"?",
">",
"clazz",
"=",
"to",
"class",
"(",
"t",
")",
";",
"if",
"(",
"clazz",
"!",
"=",
"null",
"&",
"&",
"!",
"clazz",
"is",
"interface",
"(",
")",
"&",
"&",
"clazz",
"!",
"=",
"object",
"class",
"&",
"&",
"type",
"hierarchy",
"contains",
"(",
"t",
")",
")",
"{",
"throw",
"extraction",
"error",
"(",
"\"",
"cyclic",
"reference",
"detected",
"for",
"class",
"'",
"%",
"s",
"'",
"attributes",
"of",
"structured",
"types",
"must",
"not",
"\"",
"+",
"\"",
"(",
"transitively",
")",
"reference",
"the",
"structured",
"type",
"itself",
"\"",
",",
"clazz",
"get",
"name",
"(",
")",
")",
";",
"}",
"}"
] |
[
"add",
"the",
"delegate",
"to",
"the",
"map",
"other",
"{",
"@",
"code",
"wrapped",
"collection",
"}",
"methods",
"should",
"call",
"this",
"method",
"after",
"adding",
"elements",
"to",
"a",
"previously",
"empty",
"collection",
"subcollection",
"add",
"the",
"ancestor",
"'",
"s",
"delegate",
"instead"
] |
[
"void",
"add",
"to",
"map",
"(",
")",
"{",
"if",
"(",
"ancestor",
"!",
"=",
"null",
")",
"{",
"ancestor",
"add",
"to",
"map",
"(",
")",
";",
"}",
"else",
"{",
"map",
"put",
"(",
"key",
",",
"delegate",
")",
";",
"}",
"}"
] |
[
"should",
"only",
"be",
"set",
"by",
"{",
"@",
"link",
"org",
"thoughtcrime",
"securesms",
"pin",
"pin",
"state",
"}"
] |
[
"public",
"synchronized",
"void",
"on",
"pin",
"create",
"failure",
"(",
")",
"{",
"put",
"long",
"(",
"last",
"create",
"failed",
"timestamp",
",",
"system",
"current",
"time",
"millis",
"(",
")",
")",
";",
"}"
] |
[
"cleanup",
"expired",
"entries",
"when",
"the",
"lock",
"is",
"available"
] |
[
"void",
"try",
"expire",
"entries",
"(",
"long",
"now",
")",
"{",
"if",
"(",
"try",
"lock",
"(",
")",
")",
"{",
"try",
"{",
"expire",
"entries",
"(",
"now",
")",
";",
"}",
"finally",
"{",
"unlock",
"(",
")",
";",
"/",
"/",
"don",
"'",
"t",
"call",
"post",
"write",
"cleanup",
"as",
"we",
"'",
"re",
"in",
"a",
"read",
"}",
"}",
"}"
] |
[
"sets",
"output",
"surface"
] |
[
"protected",
"final",
"void",
"set",
"output",
"surface",
"(",
"@",
"nullable",
"surface",
"surface",
")",
"{",
"if",
"(",
"this",
"surface",
"!",
"=",
"surface",
")",
"{",
"/",
"/",
"the",
"output",
"has",
"changed",
"this",
"surface",
"=",
"surface",
";",
"if",
"(",
"surface",
"!",
"=",
"null",
")",
"{",
"output",
"buffer",
"renderer",
"=",
"null",
";",
"output",
"mode",
"=",
"c",
"video",
"output",
"mode",
"surface",
"yuv",
";",
"if",
"(",
"decoder",
"!",
"=",
"null",
")",
"{",
"set",
"decoder",
"output",
"mode",
"(",
"output",
"mode",
")",
";",
"}",
"on",
"output",
"changed",
"(",
")",
";",
"}",
"else",
"{",
"/",
"/",
"the",
"output",
"has",
"been",
"removed",
"we",
"leave",
"the",
"output",
"mode",
"of",
"the",
"underlying",
"decoder",
"unchanged",
"/",
"/",
"in",
"anticipation",
"that",
"a",
"subsequent",
"output",
"will",
"likely",
"be",
"of",
"the",
"same",
"type",
"output",
"mode",
"=",
"c",
"video",
"output",
"mode",
"none",
";",
"on",
"output",
"removed",
"(",
")",
";",
"}",
"}",
"else",
"if",
"(",
"surface",
"!",
"=",
"null",
")",
"{",
"/",
"/",
"the",
"output",
"is",
"unchanged",
"and",
"non",
"-",
"null",
"on",
"output",
"reset",
"(",
")",
";",
"}",
"}"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.