Datasets:
Anonymous2023
/
KGSum

Dataset card Data Studio Files Community
docstring_tokens
list
code_tokens
list
[ "try", "to", "parse", "an", "external", "value", "if", "any" ]
[ "public", "final", "<", "t", ">", "t", "parse", "external", "value", "(", "class", "<", "t", ">", "clazz", ")", "{", "if", "(", "!", "external", "value", "set", "(", ")", "|", "|", "external", "value", "(", ")", "=", "=", "null", ")", "{", "return", "null", ";", "}", "if", "(", "!", "clazz", "is", "instance", "(", "external", "value", "(", ")", ")", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "illegal", "external", "value", "class", "[", "\"", "+", "external", "value", "(", ")", "get", "class", "(", ")", "get", "name", "(", ")", "+", "\"", "]", "should", "be", "\"", "+", "clazz", "get", "name", "(", ")", ")", ";", "}", "return", "clazz", "cast", "(", "external", "value", "(", ")", ")", ";", "}" ]
[ "groups", "a", "{", "@", "link", "data", "set", "}", "using", "a", "{", "@", "link", "key", "selector", "}", "function", "the", "key", "selector", "function", "is", "called", "for", "each", "element", "of", "the", "data", "set", "and", "extracts", "a", "single", "key", "value", "on", "which", "the", "data", "set", "is", "grouped", "this", "method", "returns", "an", "{", "@", "link", "unsorted", "grouping", "}", "on", "which", "one", "of", "the", "following", "grouping", "transformation", "can", "be", "applied", "{", "@", "link", "unsorted", "grouping", "#", "sort", "group", "(", "int", ",", "org", "apache", "flink", "api", "common", "operators", "order", ")", "}", "to", "get", "a", "{", "@", "link", "sorted", "grouping", "}", "{", "@", "link", "unsorted", "grouping", "#", "aggregate", "(", "aggregations", ",", "int", ")", "}", "to", "apply", "an", "aggregate", "transformation", "{", "@", "link", "unsorted", "grouping", "#", "reduce", "(", "org", "apache", "flink", "api", "common", "functions", "reduce", "function", ")", "}", "to", "apply", "a", "reduce", "transformation", "{", "@", "link", "unsorted", "grouping", "#", "reduce", "group", "(", "org", "apache", "flink", "api", "common", "functions", "group", "reduce", "function", ")", "}", "to", "apply", "a", "group", "reduce", "transformation" ]
[ "public", "<", "k", ">", "unsorted", "grouping", "<", "t", ">", "group", "by", "(", "key", "selector", "<", "t", ",", "k", ">", "key", "extractor", ")", "{", "type", "information", "<", "k", ">", "key", "type", "=", "type", "extractor", "get", "key", "selector", "types", "(", "key", "extractor", ",", "get", "type", "(", ")", ")", ";", "return", "new", "unsorted", "grouping", "<", ">", "(", "this", ",", "new", "keys", "selector", "function", "keys", "<", ">", "(", "clean", "(", "key", "extractor", ")", ",", "get", "type", "(", ")", ",", "key", "type", ")", ")", ";", "}" ]
[ "log", "an", "error", "of", "the", "specified", "category" ]
[ "public", "void", "log", "error", "(", "cache", "error", "category", "category", ",", "class", "<", "?", ">", "clazz", ",", "string", "message", ",", "@", "nullable", "throwable", "throwable", ")", "{", "}" ]
[ "returns", "the", "byte", "index", "from", "the", "start", "of", "the", "file", "to", "the", "external", "reference", "table" ]
[ "public", "int", "get", "referenced", "symbol", "table", "offset", "(", ")", "{", "return", "extrefsymoff", ";", "}" ]
[ "adds", "an", "edge", "to", "the", "graph", "if", "either", "endpoint", "is", "not", "in", "the", "graph", "add", "it", "if", "the", "edge", "is", "already", "in", "the", "graph", "return", "false", "and", "do", "nothing" ]
[ "public", "boolean", "add", "(", "edge", "e", ")", "{", "if", "(", "contains", "(", "e", ")", ")", "{", "return", "false", ";", "}", "else", "if", "(", "next", "index", ">", "=", "capacity", ")", "{", "grow", "(", ")", ";", "}", "edges", "[", "next", "index", "]", "=", "e", ";", "edge", "indices", "add", "(", "e", "key", "(", ")", ",", "next", "index", "+", "+", ")", ";", "vertex", "set", "vertices", "=", "parent", "graph", "vertices", "(", ")", ";", "vertex", "from", "=", "e", "from", "(", ")", ";", "vertex", "to", "=", "e", "to", "(", ")", ";", "if", "(", "!", "vertices", "contains", "(", "from", ")", ")", "{", "vertices", "add", "(", "from", ")", ";", "}", "if", "(", "!", "vertices", "contains", "(", "to", ")", ")", "{", "vertices", "add", "(", "to", ")", ";", "}", "edge", "old", "last", "outgoing", "edge", "=", "vertices", "get", "last", "outgoing", "edge", "(", "from", ")", ";", "if", "(", "old", "last", "outgoing", "edge", "=", "=", "null", ")", "{", "vertices", "set", "first", "outgoing", "edge", "(", "from", ",", "e", ")", ";", "vertices", "set", "last", "outgoing", "edge", "(", "from", ",", "e", ")", ";", "}", "else", "{", "vertices", "set", "last", "outgoing", "edge", "(", "from", ",", "e", ")", ";", "set", "next", "edge", "with", "same", "from", "(", "old", "last", "outgoing", "edge", ",", "e", ")", ";", "set", "previous", "edge", "with", "same", "from", "(", "e", ",", "old", "last", "outgoing", "edge", ")", ";", "}", "edge", "old", "last", "incoming", "edge", "=", "vertices", "get", "last", "incoming", "edge", "(", "to", ")", ";", "if", "(", "old", "last", "incoming", "edge", "=", "=", "null", ")", "{", "vertices", "set", "first", "incoming", "edge", "(", "to", ",", "e", ")", ";", "vertices", "set", "last", "incoming", "edge", "(", "to", ",", "e", ")", ";", "}", "else", "{", "vertices", "set", "last", "incoming", "edge", "(", "to", ",", "e", ")", ";", "set", "next", "edge", "with", "same", "to", "(", "old", "last", "incoming", "edge", ",", "e", ")", ";", "set", "previous", "edge", "with", "same", "to", "(", "e", ",", "old", "last", "incoming", "edge", ")", ";", "}", "modification", "number", "+", "+", ";", "return", "true", ";", "}" ]
[ "remove", "the", "view", "from", "this", "project" ]
[ "public", "void", "remove", "project", "view", "(", "url", "url", ")", "{", "project", "file", "manager", "data", "mgr", "=", "other", "views", "remove", "(", "url", ")", ";", "if", "(", "data", "mgr", "!", "=", "null", ")", "{", "data", "mgr", "dispose", "(", ")", ";", "msg", "info", "(", "this", ",", "\"", "closed", "project", "view", ":", "\"", "+", "ghidra", "u", "r", "l", "get", "display", "string", "(", "url", ")", ")", ";", "changed", "=", "true", ";", "}", "}" ]
[ "task", "to", "invoke", "when", "a", "receipt", "is", "received" ]
[ "void", "add", "receipt", "task", "(", "runnable", "runnable", ")", ";" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "final", "boolean", "fits", "in", "int", "(", ")", "{", "return", "(", "int", ")", "bits", "=", "=", "bits", ";", "}" ]
[ "in", "non", "-", "ha", "setup", ",", "after", "rolling", "upgrade", "prepare", ",", "the", "secondary", "nn", "should", "still", "be", "able", "to", "do", "checkpoint" ]
[ "public", "void", "test", "checkpoint", "with", "s", "n", "n", "(", ")", "throws", "exception", "{", "mini", "d", "f", "s", "cluster", "cluster", "=", "null", ";", "distributed", "file", "system", "dfs", "=", "null", ";", "secondary", "name", "node", "snn", "=", "null", ";", "try", "{", "configuration", "conf", "=", "new", "hdfs", "configuration", "(", ")", ";", "cluster", "=", "new", "mini", "d", "f", "s", "cluster", "builder", "(", "conf", ")", "build", "(", ")", ";", "cluster", "wait", "active", "(", ")", ";", "conf", "set", "(", "d", "f", "s", "config", "keys", "dfs", "namenode", "secondary", "http", "address", "key", ",", "\"", "0", "0", "0", "0", ":", "0", "\"", ")", ";", "snn", "=", "new", "secondary", "name", "node", "(", "conf", ")", ";", "dfs", "=", "cluster", "get", "file", "system", "(", ")", ";", "dfs", "mkdirs", "(", "new", "path", "(", "\"", "/", "test", "/", "foo", "\"", ")", ")", ";", "snn", "do", "checkpoint", "(", ")", ";", "/", "/", "start", "rolling", "upgrade", "dfs", "set", "safe", "mode", "(", "safe", "mode", "action", "safemode", "enter", ")", ";", "dfs", "rolling", "upgrade", "(", "rolling", "upgrade", "action", "prepare", ")", ";", "dfs", "set", "safe", "mode", "(", "safe", "mode", "action", "safemode", "leave", ")", ";", "dfs", "mkdirs", "(", "new", "path", "(", "\"", "/", "test", "/", "bar", "\"", ")", ")", ";", "/", "/", "do", "checkpoint", "in", "snn", "again", "snn", "do", "checkpoint", "(", ")", ";", "}", "finally", "{", "i", "o", "utils", "cleanup", "(", "null", ",", "dfs", ")", ";", "if", "(", "snn", "!", "=", "null", ")", "{", "snn", "shutdown", "(", ")", ";", "}", "if", "(", "cluster", "!", "=", "null", ")", "{", "cluster", "shutdown", "(", ")", ";", "}", "}", "}" ]
[ "gets", "the", "address", "of", "the", "unwind", "map", ",", "if", "there", "is", "one", "otherwise", ",", "this", "returns", "null" ]
[ "public", "address", "get", "unwind", "map", "address", "(", ")", "throws", "invalid", "data", "type", "exception", "{", "check", "validity", "(", ")", ";", "/", "/", "component", "2", "is", "unwind", "map", "pointer", "or", "displacement", "address", "map", "address", "=", "e", "h", "data", "type", "utilities", "get", "address", "(", "get", "data", "type", "(", ")", ",", "unwind", "map", "ordinal", ",", "get", "mem", "buffer", "(", ")", ")", ";", "return", "get", "adjusted", "address", "(", "map", "address", ",", "get", "unwind", "count", "(", ")", ")", ";", "}" ]
[ "gets", "the", "next", "{", "@", "link", "request", "interceptor", "}", "in", "the", "chain" ]
[ "public", "request", "interceptor", "get", "next", "interceptor", "(", ")", "{", "return", "this", "next", "interceptor", ";", "}" ]
[ "return", "the", "first", "header", "value", "for", "the", "given", "header", "name", ",", "if", "any" ]
[ "public", "string", "get", "first", "(", "string", "header", "name", ")", "{", "return", "this", "headers", "get", "first", "(", "header", "name", ")", ";", "}" ]
[ "parse", "groovy", "script", "groovy", "object" ]
[ "public", "static", "groovy", "object", "parse", "groovy", "script", "(", "final", "resource", "groovy", "script", ",", "final", "boolean", "fail", "on", "error", ")", "{", "return", "access", "controller", "do", "privileged", "(", "(", "privileged", "action", "<", "groovy", "object", ">", ")", "(", ")", "-", ">", "{", "val", "parent", "=", "scripting", "utils", "class", "get", "class", "loader", "(", ")", ";", "try", "(", "val", "loader", "=", "new", "groovy", "class", "loader", "(", "parent", ")", ")", "{", "val", "groovy", "class", "=", "load", "groovy", "class", "(", "groovy", "script", ",", "loader", ")", ";", "if", "(", "groovy", "class", "!", "=", "null", ")", "{", "logger", "trace", "(", "\"", "creating", "groovy", "object", "instance", "from", "class", "[", "{", "}", "]", "\"", ",", "groovy", "script", "get", "u", "r", "i", "(", ")", "get", "path", "(", ")", ")", ";", "return", "(", "groovy", "object", ")", "groovy", "class", "get", "declared", "constructor", "(", ")", "new", "instance", "(", ")", ";", "}", "logger", "warn", "(", "\"", "groovy", "script", "at", "[", "{", "}", "]", "does", "not", "exist", "\"", ",", "groovy", "script", "get", "u", "r", "i", "(", ")", "get", "path", "(", ")", ")", ";", "}", "catch", "(", "final", "exception", "e", ")", "{", "if", "(", "fail", "on", "error", ")", "{", "throw", "new", "runtime", "exception", "(", "e", ")", ";", "}", "logging", "utils", "error", "(", "logger", ",", "e", ")", ";", "}", "return", "null", ";", "}", ")", ";", "}" ]
[ "pretty", "-", "print", "the", "environment", "to", "a", "string", "builder" ]
[ "public", "static", "string", "env", "to", "string", "(", "map", "<", "string", ",", "string", ">", "env", ")", "{", "string", "builder", "bld", "=", "new", "string", "builder", "(", ")", ";", "bld", "append", "(", "\"", "{", "\"", ")", ";", "if", "(", "env", "!", "=", "null", ")", "{", "for", "(", "map", "entry", "<", "string", ",", "string", ">", "entry", ":", "env", "entry", "set", "(", ")", ")", "{", "string", "val", "=", "entry", "get", "value", "(", ")", ";", "if", "(", "val", "=", "=", "null", ")", "{", "val", "=", "\"", "\"", ";", "}", "bld", "append", "(", "\"", "\\", "n", "\"", ")", "append", "(", "entry", "get", "key", "(", ")", ")", "append", "(", "\"", "=", "'", "\"", ")", "append", "(", "val", ")", "append", "(", "\"", "'", "\\", "n", "\"", ")", ";", "}", "}", "bld", "append", "(", "\"", "}", "\"", ")", ";", "return", "bld", "to", "string", "(", ")", ";", "}" ]
[ "there", "'", "s", "several", "events", "where", "a", "registration", "may", "or", "may", "not", "be", "considered", "complete", "based", "on", "what", "path", "a", "user", "has", "taken", "this", "will", "only", "truly", "mark", "registration", "as", "complete", "if", "all", "of", "the", "requirements", "are", "met" ]
[ "public", "static", "void", "maybe", "mark", "registration", "complete", "(", "@", "non", "null", "context", "context", ")", "{", "if", "(", "!", "signal", "store", "registration", "values", "(", ")", "is", "registration", "complete", "(", ")", "&", "&", "text", "secure", "preferences", "is", "push", "registered", "(", "context", ")", "&", "&", "!", "recipient", "self", "(", ")", "get", "profile", "name", "(", ")", "is", "empty", "(", ")", "&", "&", "(", "signal", "store", "kbs", "values", "(", ")", "has", "pin", "(", ")", "|", "|", "signal", "store", "kbs", "values", "(", ")", "has", "opted", "out", "(", ")", ")", ")", "{", "log", "i", "(", "tag", ",", "\"", "marking", "registration", "completed", "\"", ",", "new", "throwable", "(", ")", ")", ";", "signal", "store", "registration", "values", "(", ")", "set", "registration", "complete", "(", ")", ";", "application", "dependencies", "get", "job", "manager", "(", ")", "start", "chain", "(", "new", "storage", "sync", "job", "(", ")", ")", "then", "(", "new", "directory", "refresh", "job", "(", "false", ")", ")", "enqueue", "(", ")", ";", "}", "else", "if", "(", "!", "signal", "store", "registration", "values", "(", ")", "is", "registration", "complete", "(", ")", ")", "{", "log", "i", "(", "tag", ",", "\"", "registration", "is", "not", "yet", "complete", "\"", ",", "new", "throwable", "(", ")", ")", ";", "}", "}" ]
[ "send", "heartbeat", "message", "to", "leader", "instance", "to", "check", "whether", "the", "leader", "instance", "is", "alive" ]
[ "boolean", "send", "heartbeat", "message", "(", "int", "leader", "id", ")", ";" ]
[ "set", "whether", "we", "'", "re", "defaulting", "java", "primitives", "in", "the", "case", "of", "mapping", "a", "null", "value", "from", "corresponding", "database", "fields", "default", "is", "{", "@", "code", "false", "}", ",", "throwing", "an", "exception", "when", "nulls", "are", "mapped", "to", "java", "primitives" ]
[ "public", "void", "set", "primitives", "defaulted", "for", "null", "value", "(", "boolean", "primitives", "defaulted", "for", "null", "value", ")", "{", "this", "primitives", "defaulted", "for", "null", "value", "=", "primitives", "defaulted", "for", "null", "value", ";", "}" ]
[ "creates", "a", "simple", "2", "vertex", "graph", "with", "a", "parallel", "source", "and", "a", "parallel", "target" ]
[ "private", "execution", "graph", "create", "test", "graph", "(", "int", "parallelism", ",", "boolean", "all", "to", "all", ")", "throws", "exception", "{", "job", "vertex", "source", "=", "new", "job", "vertex", "(", "\"", "source", "\"", ",", "source", "vertex", "id", ")", ";", "source", "set", "parallelism", "(", "parallelism", ")", ";", "source", "set", "invokable", "class", "(", "no", "op", "invokable", "class", ")", ";", "job", "vertex", "target", "=", "new", "job", "vertex", "(", "\"", "source", "\"", ",", "target", "vertex", "id", ")", ";", "target", "set", "parallelism", "(", "parallelism", ")", ";", "target", "set", "invokable", "class", "(", "no", "op", "invokable", "class", ")", ";", "distribution", "pattern", "connection", "pattern", "=", "all", "to", "all", "?", "distribution", "pattern", "all", "to", "all", ":", "distribution", "pattern", "pointwise", ";", "target", "connect", "new", "data", "set", "as", "input", "(", "source", ",", "connection", "pattern", ",", "result", "partition", "type", "pipelined", ")", ";", "job", "graph", "test", "job", "=", "new", "job", "graph", "(", "job", "id", ",", "\"", "test", "job", "\"", ",", "source", ",", "target", ")", ";", "return", "testing", "execution", "graph", "builder", "new", "builder", "(", ")", "set", "job", "graph", "(", "test", "job", ")", "build", "(", ")", ";", "}" ]
[ "for", "<", "code", ">", "gpu", "count", "<", "code", ">", "g", "p", "us", "allocated", "by", "the", "topology", "algorithm", ",", "return", "its", "performance", "boost", "against", "the", "median", "value" ]
[ "private", "float", "calculate", "performance", "boost", "against", "median", "(", "actual", "performance", "report", "report", ",", "string", "model", ",", "int", "bs", ",", "int", "gpu", "count", ",", "nvidia", "g", "p", "u", "plugin", "for", "runtime", "v", "2", "plugin", ",", "set", "<", "device", ">", "all", "device", ",", "map", "<", "string", ",", "string", ">", "env", ")", "{", "set", "<", "device", ">", "allocation", "=", "plugin", "allocate", "devices", "(", "all", "device", ",", "gpu", "count", ",", "env", ")", ";", "string", "gpu", "allocation", "string", "=", "convert", "allocation", "to", "gpu", "string", "(", "allocation", ")", ";", "float", "[", "]", "metrics", "=", "report", "get", "various", "image", "per", "second", "(", "model", ",", "bs", ",", "gpu", "count", ",", "gpu", "allocation", "string", ")", ";", "return", "metrics", "[", "7", "]", ";", "}" ]
[ "get", "my", "boolean" ]
[ "public", "boolean", "get", "my", "boolean", "(", ")", "{", "return", "my", "boolean", ";", "}" ]
[ "returns", "parts", "of", "the", "source", "buffer", "based", "on", "offsets" ]
[ "string", "buffer", "slice", "(", "int", "start", ",", "int", "end", ")", "{", "return", "new", "string", "(", "this", "buffer", ",", "start", ",", "end", "-", "start", ")", ";", "}" ]
[ "returns", "the", "set", "of", "fragment", "classes", "contained", "in", "these", "options" ]
[ "public", "set", "<", "class", "<", "?", "extends", "fragment", "options", ">", ">", "get", "fragment", "classes", "(", ")", "{", "return", "fragment", "options", "map", "key", "set", "(", ")", ";", "}" ]
[ "delete", "lazy", "-", "persist", "file", "that", "has", "not", "been", "persisted", "to", "disk", "memory", "is", "freed", "up", "and", "file", "is", "gone" ]
[ "public", "void", "test", "delete", "before", "persist", "(", ")", "throws", "exception", "{", "get", "cluster", "builder", "(", ")", "build", "(", ")", ";", "final", "string", "method", "name", "=", "generic", "test", "utils", "get", "method", "name", "(", ")", ";", "final", "data", "node", "dn", "=", "cluster", "get", "data", "nodes", "(", ")", "get", "(", "0", ")", ";", "fs", "dataset", "test", "util", "stop", "lazy", "writer", "(", "dn", ")", ";", "path", "path", "=", "new", "path", "(", "\"", "/", "\"", "+", "method", "name", "+", "\"", "dat", "\"", ")", ";", "make", "test", "file", "(", "path", ",", "block", "size", ",", "true", ")", ";", "located", "blocks", "located", "blocks", "=", "ensure", "file", "replicas", "on", "storage", "type", "(", "path", ",", "ram", "disk", ")", ";", "/", "/", "delete", "before", "persist", "client", "delete", "(", "path", "to", "string", "(", ")", ",", "false", ")", ";", "assert", "assert", "false", "(", "fs", "exists", "(", "path", ")", ")", ";", "assert", "that", "(", "verify", "deleted", "blocks", "(", "located", "blocks", ")", ",", "is", "(", "true", ")", ")", ";", "verify", "ram", "disk", "j", "m", "x", "metric", "(", "\"", "ram", "disk", "blocks", "deleted", "before", "lazy", "persisted", "\"", ",", "1", ")", ";", "}" ]
[ "bootstrap", "standby", "when", "the", "existing", "nn", "is", "standby" ]
[ "public", "void", "test", "bootstrap", "standby", "with", "standby", "n", "n", "(", ")", "throws", "exception", "{", "/", "/", "make", "the", "first", "nn", "in", "standby", "state", "cluster", "transition", "to", "standby", "(", "0", ")", ";", "bootstrap", "standbys", "(", ")", ";", "}" ]
[ "filter", "node", "only", "expects", "a", "single", "upstream", "plan", "node" ]
[ "public", "plan", "node", "get", "source", "(", ")", "{", "return", "source", ";", "}" ]
[ "the", "{", "@", "link", "priority", "}", "for", "this", "cluster", "state", "update", "task", "configuration" ]
[ "priority", "priority", "(", ")", ";" ]
[ "compares", "the", "specified", "object", "with", "this", "cell", "for", "equality", "two", "cells", "are", "equal", "when", "they", "have", "equal", "row", "keys", ",", "column", "keys", ",", "and", "values" ]
[ "boolean", "equals", "(", "@", "nullable", "decl", "object", "obj", ")", ";" ]
[ "appends", "a", "named", "{", "@", "code", "int", "}", "array", "value", "to", "the", "stream" ]
[ "public", "u", "b", "json", "writer", "set", "(", "string", "name", ",", "int", "[", "]", "value", ")", "throws", "i", "o", "exception", "{", "return", "name", "(", "name", ")", "value", "(", "value", ")", ";", "}" ]
[ "set", "to", "the", "list", "of", "auxiliary", "services", "which", "have", "been", "started", "on", "the", "<", "code", ">", "node", "manager", "<", "code", ">", "this", "is", "done", "only", "once", "when", "the", "<", "code", ">", "node", "manager", "<", "code", ">", "starts", "up" ]
[ "public", "abstract", "void", "set", "all", "services", "meta", "data", "(", "map", "<", "string", ",", "byte", "buffer", ">", "all", "services", "meta", "data", ")", ";" ]
[ "see", "{", "@", "link", "stream", "tracer", "#", "outbound", "message", "sent", "}", "called", "from", "{", "@", "link", "io", "grpc", "internal", "framer", "}" ]
[ "public", "void", "outbound", "message", "sent", "(", "int", "seq", "no", ",", "long", "optional", "wire", "size", ",", "long", "optional", "uncompressed", "size", ")", "{", "for", "(", "stream", "tracer", "tracer", ":", "tracers", ")", "{", "tracer", "outbound", "message", "sent", "(", "seq", "no", ",", "optional", "wire", "size", ",", "optional", "uncompressed", "size", ")", ";", "}", "}" ]
[ "clear", "the", "stored", "history", "of", "sent", "records", ",", "consumer", "group", "offsets" ]
[ "public", "synchronized", "void", "clear", "(", ")", "{", "this", "sent", "clear", "(", ")", ";", "this", "uncommitted", "sends", "clear", "(", ")", ";", "this", "sent", "offsets", "=", "false", ";", "this", "completions", "clear", "(", ")", ";", "this", "consumer", "group", "offsets", "clear", "(", ")", ";", "this", "uncommitted", "consumer", "group", "offsets", "clear", "(", ")", ";", "}" ]
[ "to", "test", "special", "tags", "to", "test", "special", "tags", "and", "operation", "id", "starting", "with", "number" ]
[ "observable", "<", "client", ">", "call", "1", "2", "3test", "special", "tags", "(", "@", "retrofit", "2", "http", "body", "client", "body", ")", ";" ]
[ "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", "\"", ")", ";", "}" ]
[ "update", "container", "and", "utilization", "information", "on", "the", "node", "manager" ]
[ "protected", "void", "update", "node", "resource", "utilization", "(", "r", "m", "node", "nm", ",", "scheduler", "node", "scheduler", "node", ")", "{", "/", "/", "updating", "node", "resource", "utilization", "scheduler", "node", "set", "aggregated", "containers", "utilization", "(", "nm", "get", "aggregated", "containers", "utilization", "(", ")", ")", ";", "scheduler", "node", "set", "node", "utilization", "(", "nm", "get", "node", "utilization", "(", ")", ")", ";", "}" ]
[ "identify", "external", "addresses", "which", "need", "to", "be", "analyzed", "note", ":", "this", "is", "a", "convenience", "method", "for", "block", "added" ]
[ "public", "void", "external", "added", "(", "address", "ext", "addr", ")", "{", "if", "(", "ignore", "changes", ")", "{", "return", ";", "}", "if", "(", "ext", "addr", "!", "=", "null", ")", "{", "byte", "tasks", "notify", "added", "(", "ext", "addr", ")", ";", "}", "else", "{", "byte", "tasks", "notify", "added", "(", "new", "address", "set", "(", "address", "space", "external", "space", "get", "min", "address", "(", ")", ",", "address", "space", "external", "space", "get", "max", "address", "(", ")", ")", ")", ";", "}", "}" ]
[ "when", "no", "{", "@", "link", "bundle", "}", "is", "available", ",", "{", "@", "link", "#", "get", "bundle", "(", ")", "}", "will", "return", "{", "@", "code", "null", "}" ]
[ "public", "string", "get", "bundle", "location", "(", ")", "{", "return", "bundle", "location", "!", "=", "null", "?", "bundle", "location", ":", "bundle", "get", "location", "(", ")", ";", "}" ]
[ "creates", "a", "new", "{", "@", "link", "amazon", "s", "3", "}", "client" ]
[ "amazon", "s", "3", "create", "s", "3", "client", "(", "uri", "name", ",", "string", "bucket", ",", "a", "w", "s", "credentials", "provider", "credential", "set", ",", "string", "user", "agent", "suffix", ",", "statistics", "from", "aws", "sdk", "statistics", "from", "aws", "sdk", ")", "throws", "i", "o", "exception", ";" ]
[ "returns", "true", "if", "this", "symbol", "represents", "a", "section" ]
[ "public", "boolean", "is", "section", "(", ")", "{", "if", "(", "e", "type", "=", "=", "coff", "symbol", "type", "t", "null", ")", "{", "if", "(", "e", "value", "=", "=", "0", ")", "{", "if", "(", "e", "sclass", "=", "=", "coff", "symbol", "storage", "class", "c", "stat", ")", "{", "for", "(", "coff", "symbol", "aux", "aux", ":", "auxiliary", "symbols", ")", "{", "if", "(", "aux", "instanceof", "coff", "symbol", "aux", "section", ")", "{", "return", "true", ";", "}", "}", "}", "}", "}", "return", "false", ";", "}" ]
[ "apply", "authentication", "settings", "to", "header", "and", "query", "params" ]
[ "void", "apply", "to", "params", "(", "list", "<", "pair", ">", "query", "params", ",", "map", "<", "string", ",", "string", ">", "header", "params", ",", "map", "<", "string", ",", "string", ">", "cookie", "params", ")", ";" ]
[ "sets", "an", "{", "@", "link", "priority", "task", "manager", "}", "that", "will", "be", "used", "by", "the", "player", "the", "priority", "{", "@", "link", "c", "#", "priority", "playback", "}", "will", "be", "set", "while", "the", "player", "is", "loading" ]
[ "public", "builder", "set", "priority", "task", "manager", "(", "@", "nullable", "priority", "task", "manager", "priority", "task", "manager", ")", "{", "assertions", "check", "state", "(", "!", "build", "called", ")", ";", "this", "priority", "task", "manager", "=", "priority", "task", "manager", ";", "return", "this", ";", "}" ]
[ "returns", "a", "{", "@", "link", "request", "builder", "}", "for", "a", "given", "item", "on", "which", "{", "@", "link", "request", "builder", "#", "load", "(", "object", ")", "}", "}", "has", "been", "called", "or", "{", "@", "code", "null", "}", "if", "no", "valid", "load", "can", "be", "started", "for", "the", "preloader", "to", "be", "effective", ",", "the", "{", "@", "link", "request", "builder", "}", "returned", "here", "must", "use", "exactly", "the", "same", "size", "and", "set", "of", "options", "as", "the", "{", "@", "link", "request", "builder", "}", "used", "when", "the", "`", "`", "view", "`", "`", "is", "bound", "you", "may", "need", "to", "specify", "a", "size", "in", "both", "places", "to", "ensure", "that", "the", "width", "and", "height", "match", "exactly", "if", "so", ",", "you", "can", "use", "{", "@", "link", "com", "bumptech", "glide", "request", "request", "options", "#", "override", "(", "int", ",", "int", ")", "}", "to", "do", "so", "the", "target", "and", "context", "will", "be", "provided", "by", "the", "preloader", "if", "{", "@", "link", "request", "builder", "#", "load", "(", "object", ")", "}", "is", "not", "called", "by", "this", "method", ",", "the", "preloader", "will", "trigger", "a", "{", "@", "link", "runtime", "exception", "}", "if", "you", "don", "'", "t", "want", "to", "load", "a", "particular", "item", "or", "position", ",", "filter", "it", "from", "the", "list", "returned", "by", "{", "@", "link", "#", "get", "preload", "items", "(", "int", ")", "}" ]
[ "request", "builder", "<", "?", ">", "get", "preload", "request", "builder", "(", "@", "non", "null", "u", "item", ")", ";" ]
[ "mark", "the", "request", "as", "handled" ]
[ "public", "void", "mark", "handled", "(", ")", "{", "this", "handled", "=", "true", ";", "}" ]
[ "is", "this", "type", "a", "{", "@", "link", "collection", "}", "type", "?" ]
[ "public", "boolean", "is", "collection", "(", ")", "{", "return", "collection", "class", "is", "assignable", "from", "(", "get", "type", "(", ")", ")", ";", "}" ]
[ "for", "use", "in", "mathematical", "operators", ",", "handles", "converting", "from", "a", "(", "possibly", "boxed", ")", "number", "on", "the", "stack", "to", "a", "primitive", "numeric", "type", "for", "example", ",", "from", "a", "integer", "to", "a", "double", ",", "just", "need", "to", "call", "'", "number", "double", "value", "(", ")", "'", "but", "from", "an", "int", "to", "a", "double", ",", "need", "to", "use", "the", "bytecode", "'", "i", "2d", "'" ]
[ "public", "static", "void", "insert", "numeric", "unbox", "or", "primitive", "type", "coercion", "(", "method", "visitor", "mv", ",", "@", "nullable", "string", "stack", "descriptor", ",", "char", "target", "descriptor", ")", "{", "if", "(", "!", "code", "flow", "is", "primitive", "(", "stack", "descriptor", ")", ")", "{", "code", "flow", "insert", "unbox", "number", "insns", "(", "mv", ",", "target", "descriptor", ",", "stack", "descriptor", ")", ";", "}", "else", "{", "code", "flow", "insert", "any", "necessary", "type", "conversion", "bytecodes", "(", "mv", ",", "target", "descriptor", ",", "stack", "descriptor", ")", ";", "}", "}" ]
[ "{", "@", "inherit", "doc", "}", "the", "default", "implementation", "does", "nothing" ]
[ "@", "override", "public", "void", "exit", "statement", "default", "(", "sql", "base", "parser", "statement", "default", "context", "ctx", ")", "{", "}" ]
[ "submit", "this", "job", "to", "mapred", "the", "state", "becomes", "running", "if", "submission", "is", "successful", ",", "failed", "otherwise" ]
[ "protected", "synchronized", "void", "submit", "(", ")", "{", "try", "{", "configuration", "conf", "=", "job", "get", "configuration", "(", ")", ";", "if", "(", "conf", "get", "boolean", "(", "create", "dir", ",", "false", ")", ")", "{", "file", "system", "fs", "=", "file", "system", "get", "(", "conf", ")", ";", "path", "input", "paths", "[", "]", "=", "file", "input", "format", "get", "input", "paths", "(", "job", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "input", "paths", "length", ";", "i", "+", "+", ")", "{", "if", "(", "!", "fs", "exists", "(", "input", "paths", "[", "i", "]", ")", ")", "{", "try", "{", "fs", "mkdirs", "(", "input", "paths", "[", "i", "]", ")", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "}", "}", "}", "}", "job", "submit", "(", ")", ";", "this", "state", "=", "state", "running", ";", "}", "catch", "(", "exception", "ioe", ")", "{", "log", "info", "(", "get", "job", "name", "(", ")", "+", "\"", "got", "an", "error", "while", "submitting", "\"", ",", "ioe", ")", ";", "this", "state", "=", "state", "failed", ";", "this", "message", "=", "string", "utils", "stringify", "exception", "(", "ioe", ")", ";", "}", "}" ]
[ "create", "a", "new", "webapp", "builder" ]
[ "public", "static", "<", "t", ">", "builder", "<", "t", ">", "$", "for", "(", "string", "prefix", ",", "class", "<", "t", ">", "api", ",", "t", "app", ",", "string", "ws", "prefix", ")", "{", "return", "new", "builder", "<", "t", ">", "(", "prefix", ",", "api", ",", "app", ",", "ws", "prefix", ")", ";", "}" ]
[ "adjust", "level", "of", "a", "named", "logger", "if", "name", "corresponds", "to", "an", "ancestor", ",", "then", "the", "log", "level", "is", "applied", "to", "all", "child", "loggers" ]
[ "public", "response", "set", "level", "(", "final", "@", "path", "param", "(", "\"", "logger", "\"", ")", "string", "named", "logger", ",", "final", "map", "<", "string", ",", "string", ">", "level", "map", ")", "{", "string", "desired", "level", "str", "=", "level", "map", "get", "(", "\"", "level", "\"", ")", ";", "if", "(", "desired", "level", "str", "=", "=", "null", ")", "{", "throw", "new", "bad", "request", "exception", "(", "\"", "desired", "'", "level", "'", "parameter", "was", "not", "specified", "in", "request", "\"", ")", ";", "}", "level", "level", "=", "level", "to", "level", "(", "desired", "level", "str", "to", "upper", "case", "(", "locale", "root", ")", ",", "null", ")", ";", "if", "(", "level", "=", "=", "null", ")", "{", "throw", "new", "not", "found", "exception", "(", "\"", "invalid", "log", "level", "'", "\"", "+", "desired", "level", "str", "+", "\"", "'", "\"", ")", ";", "}", "list", "<", "logger", ">", "child", "loggers", ";", "if", "(", "root", "logger", "name", "equals", "ignore", "case", "(", "named", "logger", ")", ")", "{", "child", "loggers", "=", "collections", "list", "(", "current", "loggers", "(", ")", ")", ";", "child", "loggers", "add", "(", "root", "logger", "(", ")", ")", ";", "}", "else", "{", "child", "loggers", "=", "new", "array", "list", "<", ">", "(", ")", ";", "logger", "ancestor", "logger", "=", "lookup", "logger", "(", "named", "logger", ")", ";", "enumeration", "en", "=", "current", "loggers", "(", ")", ";", "boolean", "present", "=", "false", ";", "while", "(", "en", "has", "more", "elements", "(", ")", ")", "{", "logger", "current", "=", "(", "logger", ")", "en", "next", "element", "(", ")", ";", "if", "(", "current", "get", "name", "(", ")", "starts", "with", "(", "named", "logger", ")", ")", "{", "child", "loggers", "add", "(", "current", ")", ";", "}", "if", "(", "named", "logger", "equals", "(", "current", "get", "name", "(", ")", ")", ")", "{", "present", "=", "true", ";", "}", "}", "if", "(", "!", "present", ")", "{", "child", "loggers", "add", "(", "ancestor", "logger", ")", ";", "}", "}", "list", "<", "string", ">", "modified", "logger", "names", "=", "new", "array", "list", "<", ">", "(", ")", ";", "for", "(", "logger", "logger", ":", "child", "loggers", ")", "{", "logger", "set", "level", "(", "level", ")", ";", "modified", "logger", "names", "add", "(", "logger", "get", "name", "(", ")", ")", ";", "}", "collections", "sort", "(", "modified", "logger", "names", ")", ";", "return", "response", "ok", "(", "modified", "logger", "names", ")", "build", "(", ")", ";", "}" ]
[ "multiply", "another", "matrix", "by", "this", "one", "(", "this", "one", "on", "left", ")", "djm", "optimized" ]
[ "public", "final", "mat", "2", "2", "mul", "(", "final", "mat", "2", "2", "r", ")", "{", "/", "*", "*", "mat", "2", "2", "c", "=", "new", "mat", "2", "2", "(", ")", ";", "c", "set", "(", "this", "mul", "(", "r", "ex", ")", ",", "this", "mul", "(", "r", "ey", ")", ")", ";", "return", "c", ";", "*", "/", "final", "mat", "2", "2", "c", "=", "new", "mat", "2", "2", "(", ")", ";", "c", "ex", "x", "=", "ex", "x", "*", "r", "ex", "x", "+", "ey", "x", "*", "r", "ex", "y", ";", "c", "ex", "y", "=", "ex", "y", "*", "r", "ex", "x", "+", "ey", "y", "*", "r", "ex", "y", ";", "c", "ey", "x", "=", "ex", "x", "*", "r", "ey", "x", "+", "ey", "x", "*", "r", "ey", "y", ";", "c", "ey", "y", "=", "ex", "y", "*", "r", "ey", "x", "+", "ey", "y", "*", "r", "ey", "y", ";", "/", "/", "c", "set", "(", "ex", ",", "col", "2", ")", ";", "return", "c", ";", "}" ]
[ "use", "{", "@", "link", "#", "get", "double", "map", "map", "(", ")", "}", "instead" ]
[ "public", "java", "util", "map", "<", "java", "lang", "string", ",", "org", "apache", "dubbo", "metadata", "definition", "protobuf", "model", "google", "p", "b", "phone", "number", ">", "get", "double", "map", "(", ")", "{", "return", "get", "double", "map", "map", "(", ")", ";", "}" ]
[ "iterate", "over", "the", "records", "in", "ascending", "sorted", "order", "starting", "at", "the", "specified", "start", "key" ]
[ "public", "d", "b", "field", "iterator", "field", "key", "iterator", "(", "field", "min", "key", ",", "field", "max", "key", ",", "field", "start", "key", ")", "throws", "i", "o", "exception", "{", "synchronized", "(", "db", ")", "{", "if", "(", "schema", "use", "long", "key", "nodes", "(", ")", ")", "{", "throw", "new", "assert", "exception", "(", ")", ";", "}", "return", "new", "field", "key", "iterator", "(", "min", "key", ",", "max", "key", ",", "start", "key", ")", ";", "}", "}" ]
[ "add", "item", "to", "this", "view" ]
[ "void", "add", "(", "@", "non", "null", "top", "level", "item", "item", ")", "throws", "i", "o", "exception", ",", "illegal", "argument", "exception", ";" ]
[ "like", "{", "@", "link", "#", "transform", "(", "listenable", "future", ",", "function", ",", "executor", ")", "}", "except", "that", "the", "transformation", "{", "@", "code", "function", "}", "is", "invoked", "on", "each", "call", "to", "{", "@", "link", "future", "#", "get", "(", ")", "get", "(", ")", "}", "on", "the", "returned", "future", "the", "returned", "{", "@", "code", "future", "}", "reflects", "the", "input", "'", "s", "cancellation", "state", "directly", ",", "and", "any", "attempt", "to", "cancel", "the", "returned", "future", "is", "likewise", "passed", "through", "to", "the", "input", "future", "note", "that", "calls", "to", "{", "@", "linkplain", "future", "#", "get", "(", "long", ",", "time", "unit", ")", "timed", "get", "}", "only", "apply", "the", "timeout", "to", "the", "execution", "of", "the", "underlying", "{", "@", "code", "future", "}", ",", "not", "to", "the", "execution", "of", "the", "transformation", "function", "the", "primary", "audience", "of", "this", "method", "is", "callers", "of", "{", "@", "code", "transform", "}", "who", "don", "'", "t", "have", "a", "{", "@", "code", "listenable", "future", "}", "available", "and", "do", "not", "mind", "repeated", ",", "lazy", "function", "evaluation" ]
[ "public", "static", "<", "i", ",", "o", ">", "future", "<", "o", ">", "lazy", "transform", "(", "final", "future", "<", "i", ">", "input", ",", "final", "function", "<", "?", "super", "i", ",", "?", "extends", "o", ">", "function", ")", "{", "check", "not", "null", "(", "input", ")", ";", "check", "not", "null", "(", "function", ")", ";", "return", "new", "future", "<", "o", ">", "(", ")", "{", "@", "override", "public", "boolean", "cancel", "(", "boolean", "may", "interrupt", "if", "running", ")", "{", "return", "input", "cancel", "(", "may", "interrupt", "if", "running", ")", ";", "}", "@", "override", "public", "boolean", "is", "cancelled", "(", ")", "{", "return", "input", "is", "cancelled", "(", ")", ";", "}", "@", "override", "public", "boolean", "is", "done", "(", ")", "{", "return", "input", "is", "done", "(", ")", ";", "}", "@", "override", "public", "o", "get", "(", ")", "throws", "interrupted", "exception", ",", "execution", "exception", "{", "return", "apply", "transformation", "(", "input", "get", "(", ")", ")", ";", "}", "@", "override", "public", "o", "get", "(", "long", "timeout", ",", "time", "unit", "unit", ")", "throws", "interrupted", "exception", ",", "execution", "exception", ",", "timeout", "exception", "{", "return", "apply", "transformation", "(", "input", "get", "(", "timeout", ",", "unit", ")", ")", ";", "}", "private", "o", "apply", "transformation", "(", "i", "input", ")", "throws", "execution", "exception", "{", "try", "{", "return", "function", "apply", "(", "input", ")", ";", "}", "catch", "(", "throwable", "t", ")", "{", "throw", "new", "execution", "exception", "(", "t", ")", ";", "}", "}", "}", ";", "}" ]
[ "sanity", "checking", "with", "many", "combinations", "of", "false", "positive", "rates", "and", "expected", "insertions" ]
[ "public", "void", "test", "basic", "(", ")", "{", "for", "(", "double", "fpr", "=", "0", "0000001", ";", "fpr", "<", "0", "1", ";", "fpr", "*", "=", "10", ")", "{", "for", "(", "int", "expected", "insertions", "=", "1", ";", "expected", "insertions", "<", "=", "10000", ";", "expected", "insertions", "*", "=", "10", ")", "{", "check", "sanity", "(", "bloom", "filter", "create", "(", "hash", "test", "utils", "bad", "funnel", ",", "expected", "insertions", ",", "fpr", ")", ")", ";", "}", "}", "}" ]
[ "removes", "the", "given", "drop", "target", "from", "anywhere", "within", "the", "tree", "of", "cascaded", "drop", "targets", "if", "the", "given", "<", "code", ">", "drop", "target", "<", "code", ">", "is", "an", "immediate", "child", "of", "this", "cascaded", "drop", "target", "(", "cdt", ")", ",", "then", "the", "other", "child", "is", "returned", "otherwise", ",", "a", "reference", "to", "this", "cdt", "will", "be", "returned", "with", "the", "given", "<", "code", ">", "drop", "target", "<", "code", ">", "having", "been", "removed", "from", "one", "of", "this", "cdt", "'", "s", "children", "this", "method", "effectively", "removes", "the", "given", "<", "code", ">", "drop", "target", "<", "code", ">", "from", "the", "hierarchy", "and", "collapses", "the", "tree", "structure", "as", "needed" ]
[ "public", "drop", "target", "remove", "drop", "target", "(", "drop", "target", "drop", "target", ")", "{", "/", "/", "is", "the", "child", "ours", "?", "if", "(", "primary", "drop", "target", "=", "=", "drop", "target", ")", "{", "return", "secondary", "drop", "target", ";", "}", "else", "if", "(", "secondary", "drop", "target", "=", "=", "drop", "target", ")", "{", "return", "primary", "drop", "target", ";", "}", "if", "(", "primary", "drop", "target", "instanceof", "cascaded", "drop", "target", ")", "{", "cascaded", "drop", "target", "cascaded", "drop", "target", "=", "(", "cascaded", "drop", "target", ")", "primary", "drop", "target", ";", "primary", "drop", "target", "=", "cascaded", "drop", "target", "remove", "drop", "target", "(", "drop", "target", ")", ";", "}", "if", "(", "secondary", "drop", "target", "instanceof", "cascaded", "drop", "target", ")", "{", "cascaded", "drop", "target", "cascaded", "drop", "target", "=", "(", "cascaded", "drop", "target", ")", "secondary", "drop", "target", ";", "secondary", "drop", "target", "=", "cascaded", "drop", "target", "remove", "drop", "target", "(", "drop", "target", ")", ";", "}", "return", "this", ";", "}" ]
[ "checks", "whether", "specified", "{", "@", "link", "permission", "check", "}", "is", "implied", "by", "this", "{", "@", "link", "permission", "check", "}", "<", "br", ">", "this", "is", "important", "method", "to", "be", "considered", "during", "implementation", "as", "it", "compares", "{", "@", "link", "permission", "check", "}", "s", "if", "{", "@", "code", "permission", "check", "implies", "(", "other", "permission", "check", ")", "}", ",", "that", "means", "all", "the", "actions", "allowed", "by", "{", "@", "code", "other", "permission", "check", "}", "are", "also", "allowed", "by", "{", "@", "code", "permission", "check", "}", ",", "irrespective", "of", "the", "request", "structure" ]
[ "boolean", "implies", "(", "permission", "check", "other", "permission", "check", ")", ";" ]
[ "returns", "an", "array", "of", "segment", "indicies", "that", "receive", "code", "from", "the", "module" ]
[ "public", "short", "[", "]", "get", "segments", "(", ")", "{", "return", "segs", ";", "}" ]
[ "deletes", "the", "fingerprint", "with", "the", "given", "unique", "id" ]
[ "public", "void", "delete", "(", "string", "id", ")", "throws", "i", "o", "exception", "{", "file", "file", "=", "get", "fingerprint", "file", "(", "id", ")", ";", "if", "(", "!", "file", "exists", "(", ")", ")", "{", "return", ";", "}", "if", "(", "!", "file", "delete", "(", ")", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "error", "occurred", "in", "deleting", "fingerprint", "\"", "+", "id", ")", ";", "}", "file", "inner", "=", "new", "file", "(", "jenkins", "get", "(", ")", "get", "root", "dir", "(", ")", ",", "\"", "fingerprints", "/", "\"", "+", "id", "substring", "(", "0", ",", "2", ")", "+", "\"", "/", "\"", "+", "id", "substring", "(", "2", ",", "4", ")", ")", ";", "string", "[", "]", "inner", "files", "=", "inner", "list", "(", ")", ";", "if", "(", "inner", "files", "!", "=", "null", "&", "&", "inner", "files", "length", "=", "=", "0", ")", "{", "if", "(", "!", "inner", "delete", "(", ")", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "error", "occurred", "in", "deleting", "inner", "directory", "of", "fingerprint", "\"", "+", "id", ")", ";", "}", "}", "file", "outer", "=", "new", "file", "(", "jenkins", "get", "(", ")", "get", "root", "dir", "(", ")", ",", "\"", "fingerprints", "/", "\"", "+", "id", "substring", "(", "0", ",", "2", ")", ")", ";", "string", "[", "]", "outer", "files", "=", "outer", "list", "(", ")", ";", "if", "(", "outer", "files", "!", "=", "null", "&", "&", "outer", "files", "length", "=", "=", "0", ")", "{", "if", "(", "!", "outer", "delete", "(", ")", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "error", "occurred", "in", "deleting", "outer", "directory", "of", "fingerprint", "\"", "+", "id", ")", ";", "}", "}", "}" ]
[ "cancels", "the", "give", "shard", "from", "the", "routing", "nodes", "internal", "statistics", "and", "cancels", "the", "relocation", "if", "the", "shard", "is", "relocating" ]
[ "private", "void", "remove", "(", "shard", "routing", "shard", ")", "{", "assert", "shard", "unassigned", "(", ")", "=", "=", "false", ":", "\"", "only", "assigned", "shards", "can", "be", "removed", "here", "(", "\"", "+", "shard", "+", "\"", ")", "\"", ";", "node", "(", "shard", "current", "node", "id", "(", ")", ")", "remove", "(", "shard", ")", ";", "if", "(", "shard", "initializing", "(", ")", "&", "&", "shard", "relocating", "node", "id", "(", ")", "=", "=", "null", ")", "{", "inactive", "shard", "count", "-", "-", ";", "assert", "inactive", "shard", "count", ">", "=", "0", ";", "if", "(", "shard", "primary", "(", ")", ")", "{", "inactive", "primary", "count", "-", "-", ";", "}", "}", "else", "if", "(", "shard", "relocating", "(", ")", ")", "{", "shard", "=", "cancel", "relocation", "(", "shard", ")", ";", "}", "assigned", "shards", "remove", "(", "shard", ")", ";", "if", "(", "shard", "initializing", "(", ")", ")", "{", "remove", "recovery", "(", "shard", ")", ";", "}", "}" ]
[ "get", "a", "delegation", "token", "from", "remote", "service", "endpoint", "if", "'", "fs", "azure", "enable", "kerberos", "support", "'", "is", "set", "to", "'", "true", "'" ]
[ "public", "synchronized", "token", "<", "?", ">", "get", "delegation", "token", "(", "final", "string", "renewer", ")", "throws", "i", "o", "exception", "{", "if", "(", "kerberos", "support", "enabled", ")", "{", "return", "wasb", "delegation", "token", "manager", "get", "delegation", "token", "(", "renewer", ")", ";", "}", "else", "{", "return", "super", "get", "delegation", "token", "(", "renewer", ")", ";", "}", "}" ]
[ "get", "the", "{", "@", "link", "url", "url", "'", "s", "}", "parameters", "of", "{", "@", "link", "metadata", "service", "metadata", "service", "'", "s", "}", "metadata" ]
[ "public", "static", "map", "<", "string", ",", "string", ">", "get", "metadata", "service", "u", "r", "l", "params", "(", "service", "instance", "service", "instance", ",", "string", "protocol", ")", "{", "map", "<", "string", ",", "map", "<", "string", ",", "string", ">", ">", "params", "=", "get", "metadata", "service", "u", "r", "ls", "params", "(", "service", "instance", ")", ";", "return", "params", "get", "or", "default", "(", "protocol", ",", "empty", "map", "(", ")", ")", ";", "}" ]
[ "name", "of", "the", "pet" ]
[ "public", "string", "get", "a", "t", "t", "n", "a", "m", "e", "(", ")", "{", "return", "att", "name", ";", "}" ]
[ "build", "transitions", "for", "every", "year", "in", "our", "range", "from", "the", "rules", "stored", "in", "{", "@", "link", "zone", "rules", "#", "get", "transition", "rules", "(", ")", "}" ]
[ "private", "static", "list", "<", "zone", "offset", "transition", ">", "build", "transitions", "from", "rules", "(", "list", "<", "zone", "offset", "transition", ">", "transitions", ",", "zone", "id", "zone", ",", "zone", "rules", "rules", ",", "long", "min", "second", ",", "long", "max", "second", ")", "{", "list", "<", "zone", "offset", "transition", "rule", ">", "transition", "rules", "=", "rules", "get", "transition", "rules", "(", ")", ";", "if", "(", "transition", "rules", "is", "empty", "(", ")", ")", "{", "/", "*", "*", "zones", "like", "asia", "/", "kathmandu", "don", "'", "t", "have", "any", "rules", "so", "we", "don", "'", "t", "*", "need", "to", "do", "any", "of", "this", "*", "/", "return", "transitions", ";", "}", "int", "min", "year", "=", "local", "date", "of", "instant", "(", "instant", "of", "epoch", "second", "(", "min", "second", ")", ",", "zone", ")", "get", "year", "(", ")", ";", "int", "max", "year", "=", "local", "date", "of", "instant", "(", "instant", "of", "epoch", "second", "(", "max", "second", ")", ",", "zone", ")", "get", "year", "(", ")", ";", "/", "*", "*", "record", "only", "the", "rules", "from", "the", "current", "year", "that", "are", "greater", "*", "than", "the", "min", "second", "so", "we", "don", "'", "t", "go", "back", "in", "time", "when", "coming", "from", "*", "a", "fixed", "transition", "*", "/", "zone", "offset", "transition", "last", "transition", "from", "min", "year", "=", "null", ";", "for", "(", "zone", "offset", "transition", "rule", "rule", ":", "transition", "rules", ")", "{", "last", "transition", "from", "min", "year", "=", "rule", "create", "transition", "(", "min", "year", ")", ";", "if", "(", "last", "transition", "from", "min", "year", "to", "epoch", "second", "(", ")", "<", "min", "second", ")", "{", "continue", ";", "}", "transitions", "add", "(", "last", "transition", "from", "min", "year", ")", ";", "if", "(", "transitions", "size", "(", ")", ">", "max", "transitions", ")", "{", "return", "null", ";", "}", "}", "if", "(", "min", "year", "=", "=", "max", "year", ")", "{", "if", "(", "transitions", "is", "empty", "(", ")", ")", "{", "/", "/", "make", "sure", "we", "have", "*", "some", "*", "transition", "to", "work", "with", "transitions", "add", "(", "last", "transition", "from", "min", "year", ")", ";", "}", "return", "transitions", ";", "}", "/", "/", "now", "build", "transitions", "for", "all", "of", "the", "remaining", "years", "min", "year", "+", "+", ";", "if", "(", "transitions", "size", "(", ")", "+", "(", "max", "year", "-", "min", "year", ")", "*", "transition", "rules", "size", "(", ")", ">", "max", "transitions", ")", "{", "return", "null", ";", "}", "for", "(", "int", "year", "=", "min", "year", ";", "year", "<", "=", "max", "year", ";", "year", "+", "+", ")", "{", "for", "(", "zone", "offset", "transition", "rule", "rule", ":", "transition", "rules", ")", "{", "transitions", "add", "(", "rule", "create", "transition", "(", "year", ")", ")", ";", "}", "}", "return", "transitions", ";", "}" ]
[ "finds", "the", "next", "entry", "in", "the", "current", "table", "returns", "true", "if", "an", "entry", "was", "found" ]
[ "boolean", "next", "in", "table", "(", ")", "{", "while", "(", "next", "table", "index", ">", "=", "0", ")", "{", "if", "(", "(", "next", "entry", "=", "current", "table", "get", "(", "next", "table", "index", "-", "-", ")", ")", "!", "=", "null", ")", "{", "if", "(", "advance", "to", "(", "next", "entry", ")", "|", "|", "next", "in", "chain", "(", ")", ")", "{", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}" ]
[ "this", "shows", "a", "missing", "parent", "still", "results", "in", "a", "dependency", "link", "when", "local", "endpoints", "change" ]
[ "@", "test", "protected", "void", "missing", "intermediate", "span", "(", "test", "info", "test", "info", ")", "throws", "exception", "{", "string", "test", "suffix", "=", "test", "suffix", "(", "test", "info", ")", ";", "string", "trace", "id", "=", "new", "trace", "id", "(", ")", ";", "endpoint", "frontend", "=", "suffix", "service", "name", "(", "test", "objects", "frontend", ",", "test", "suffix", ")", ";", "endpoint", "backend", "=", "suffix", "service", "name", "(", "test", "objects", "backend", ",", "test", "suffix", ")", ";", "list", "<", "span", ">", "trace", "=", "as", "list", "(", "span", "new", "builder", "(", ")", "trace", "id", "(", "trace", "id", ")", "id", "(", "\"", "20", "\"", ")", "name", "(", "\"", "get", "\"", ")", "timestamp", "(", "today", "*", "1000l", ")", "duration", "(", "350l", "*", "1000l", ")", "kind", "(", "kind", "server", ")", "local", "endpoint", "(", "frontend", ")", "build", "(", ")", ",", "/", "/", "missing", "an", "intermediate", "span", "span", "new", "builder", "(", ")", "trace", "id", "(", "trace", "id", ")", "parent", "id", "(", "\"", "21", "\"", ")", "id", "(", "\"", "22", "\"", ")", "name", "(", "\"", "get", "\"", ")", "timestamp", "(", "(", "today", "+", "150l", ")", "*", "1000l", ")", "duration", "(", "50l", "*", "1000l", ")", "kind", "(", "kind", "client", ")", "local", "endpoint", "(", "backend", ")", "build", "(", ")", ")", ";", "process", "dependencies", "(", "trace", ")", ";", "assert", "that", "(", "store", "(", ")", "get", "dependencies", "(", "end", "ts", "(", "trace", ")", ",", "day", ")", "execute", "(", ")", ")", "contains", "only", "(", "dependency", "link", "new", "builder", "(", ")", "parent", "(", "frontend", "service", "name", "(", ")", ")", "child", "(", "backend", "service", "name", "(", ")", ")", "call", "count", "(", "1", ")", "build", "(", ")", ")", ";", "}" ]
[ "sets", "the", "tooltip", "for", "the", "dismiss", "button" ]
[ "protected", "void", "set", "dismiss", "tool", "tip", "(", "string", "tooltip", ")", "{", "if", "(", "dismiss", "button", "!", "=", "null", ")", "{", "dismiss", "button", "set", "tool", "tip", "text", "(", "tooltip", ")", ";", "}", "}" ]
[ "helper", "method", "used", "to", "generate", "the", "block", "i", "ds", "the", "algorithm", "used", "is", "similar", "to", "the", "azure", "storage", "sdk" ]
[ "private", "void", "set", "blocks", "count", "and", "block", "id", "prefix", "(", "list", "<", "block", "entry", ">", "block", "entries", ")", "{", "if", "(", "next", "block", "count", "=", "=", "unset", "blocks", "count", "&", "&", "block", "id", "prefix", "=", "=", "null", ")", "{", "random", "sequence", "generator", "=", "new", "random", "(", ")", ";", "string", "block", "zero", "block", "id", "=", "(", "!", "block", "entries", "is", "empty", "(", ")", ")", "?", "block", "entries", "get", "(", "0", ")", "get", "id", "(", ")", ":", "\"", "\"", ";", "string", "prefix", "=", "uuid", "random", "u", "u", "i", "d", "(", ")", "to", "string", "(", ")", "+", "\"", "-", "\"", ";", "string", "sample", "newer", "version", "block", "id", "=", "generate", "newer", "version", "block", "id", "(", "prefix", ",", "0", ")", ";", "if", "(", "!", "block", "entries", "is", "empty", "(", ")", "&", "&", "block", "zero", "block", "id", "length", "(", ")", "<", "sample", "newer", "version", "block", "id", "length", "(", ")", ")", "{", "/", "/", "if", "blob", "has", "already", "been", "created", "with", "2", "2", "0", ",", "append", "subsequent", "blocks", "/", "/", "with", "older", "version", "(", "2", "2", "0", ")", "block", "id", "compute", "next", "block", "count", ",", "the", "way", "it", "/", "/", "was", "done", "before", ";", "and", "don", "'", "t", "use", "block", "id", "prefix", "this", "block", "id", "prefix", "=", "\"", "\"", ";", "next", "block", "count", "=", "(", "long", ")", "(", "sequence", "generator", "next", "int", "(", "integer", "max", "value", ")", ")", "+", "sequence", "generator", "next", "int", "(", "integer", "max", "value", "-", "max", "block", "count", ")", ";", "next", "block", "count", "+", "=", "block", "entries", "size", "(", ")", ";", "}", "else", "{", "/", "/", "if", "there", "are", "no", "existing", "blocks", ",", "create", "the", "first", "block", "with", "newer", "/", "/", "version", "(", "4", "2", "0", ")", "block", "id", "if", "blob", "has", "already", "been", "created", "with", "4", "2", "0", ",", "/", "/", "append", "subsequent", "blocks", "with", "newer", "version", "(", "4", "2", "0", ")", "block", "id", "this", "block", "id", "prefix", "=", "prefix", ";", "next", "block", "count", "=", "block", "entries", "size", "(", ")", ";", "}", "}", "}" ]
[ "copies", "special", "metadata", "hold", "by", "this", "instance", "to", "the", "provided", "instance" ]
[ "void", "copy", "meta", "(", "default", "binary", "memcache", "response", "dst", ")", "{", "super", "copy", "meta", "(", "dst", ")", ";", "dst", "status", "=", "status", ";", "}" ]
[ "set", "the", "value", "of", "the", "<", "code", ">", "name", "<", "code", ">", "property", "to", "a", "<", "code", ">", "long", "<", "code", ">" ]
[ "public", "void", "set", "long", "(", "string", "name", ",", "long", "value", ")", "{", "set", "(", "name", ",", "long", "to", "string", "(", "value", ")", ")", ";", "}" ]
[ "get", "namespace", "wrapped", "array" ]
[ "public", "list", "<", "integer", ">", "get", "namespace", "wrapped", "array", "(", ")", "{", "return", "namespace", "wrapped", "array", ";", "}" ]
[ "extend", "the", "configurations", "of", "one", "source", "set", "from", "another" ]
[ "public", "static", "void", "extend", "source", "set", "(", "project", "project", ",", "string", "parent", "source", "set", "name", ",", "string", "child", "source", "set", "name", ")", "{", "final", "list", "<", "function", "<", "source", "set", ",", "string", ">", ">", "config", "name", "functions", "=", "arrays", "as", "list", "(", "source", "set", ":", ":", "get", "compile", "configuration", "name", ",", "source", "set", ":", ":", "get", "implementation", "configuration", "name", ",", "source", "set", ":", ":", "get", "runtime", "configuration", "name", ",", "source", "set", ":", ":", "get", "runtime", "only", "configuration", "name", ")", ";", "source", "set", "container", "source", "sets", "=", "project", "get", "extensions", "(", ")", "get", "by", "type", "(", "source", "set", "container", "class", ")", ";", "source", "set", "parent", "=", "source", "sets", "get", "by", "name", "(", "parent", "source", "set", "name", ")", ";", "source", "set", "child", "=", "source", "sets", "get", "by", "name", "(", "child", "source", "set", "name", ")", ";", "for", "(", "function", "<", "source", "set", ",", "string", ">", "config", "name", "function", ":", "config", "name", "functions", ")", "{", "string", "parent", "config", "name", "=", "config", "name", "function", "apply", "(", "parent", ")", ";", "string", "child", "config", "name", "=", "config", "name", "function", "apply", "(", "child", ")", ";", "configuration", "parent", "config", "=", "project", "get", "configurations", "(", ")", "get", "by", "name", "(", "parent", "config", "name", ")", ";", "configuration", "child", "config", "=", "project", "get", "configurations", "(", ")", "get", "by", "name", "(", "child", "config", "name", ")", ";", "child", "config", "extends", "from", "(", "parent", "config", ")", ";", "}", "/", "/", "tie", "this", "new", "test", "source", "set", "to", "the", "main", "and", "test", "source", "sets", "child", "set", "compile", "classpath", "(", "project", "get", "objects", "(", ")", "file", "collection", "(", ")", "from", "(", "child", "get", "compile", "classpath", "(", ")", ",", "parent", "get", "output", "(", ")", ")", ")", ";", "child", "set", "runtime", "classpath", "(", "project", "get", "objects", "(", ")", "file", "collection", "(", ")", "from", "(", "child", "get", "runtime", "classpath", "(", ")", ",", "parent", "get", "output", "(", ")", ")", ")", ";", "}" ]
[ "returns", "the", "number", "of", "attributes", "of", "the", "attribute", "list", "that", "begins", "with", "this", "attribute" ]
[ "final", "int", "get", "attribute", "count", "(", ")", "{", "int", "count", "=", "0", ";", "attribute", "attribute", "=", "this", ";", "while", "(", "attribute", "!", "=", "null", ")", "{", "count", "+", "=", "1", ";", "attribute", "=", "attribute", "next", "attribute", ";", "}", "return", "count", ";", "}" ]
[ "returns", "the", "appropriate", "{", "@", "code", "move", "-", "param", "}", "rop", "for", "the", "given", "type", "the", "result", "is", "a", "shared", "instance" ]
[ "public", "static", "rop", "op", "move", "param", "(", "type", "bearer", "type", ")", "{", "switch", "(", "type", "get", "basic", "frame", "type", "(", ")", ")", "{", "case", "type", "bt", "int", ":", "return", "move", "param", "int", ";", "case", "type", "bt", "long", ":", "return", "move", "param", "long", ";", "case", "type", "bt", "float", ":", "return", "move", "param", "float", ";", "case", "type", "bt", "double", ":", "return", "move", "param", "double", ";", "case", "type", "bt", "object", ":", "return", "move", "param", "object", ";", "}", "return", "throw", "bad", "type", "(", "type", ")", ";", "}" ]
[ "get", "available", "erasure", "coding", "codecs", "and", "coders" ]
[ "static", "map", "<", "string", ",", "string", ">", "get", "erasure", "coding", "codecs", "(", "final", "f", "s", "namesystem", "fsn", ")", "throws", "i", "o", "exception", "{", "assert", "fsn", "has", "read", "lock", "(", ")", ";", "return", "codec", "registry", "get", "instance", "(", ")", "get", "codec", "2", "coder", "compact", "map", "(", ")", ";", "}" ]
[ "check", "the", "entry", "to", "determine", "if", "the", "user", "input", "is", "valid", "for", "restoring", "a", "project", "archive" ]
[ "private", "boolean", "check", "input", "(", ")", "{", "string", "archive", "name", "=", "get", "archive", "path", "name", "(", ")", ";", "if", "(", "(", "archive", "name", "=", "=", "null", ")", "|", "|", "archive", "name", "equals", "(", "\"", "\"", ")", ")", "{", "set", "status", "text", "(", "\"", "specify", "a", "valid", "archive", "file", "\"", ")", ";", "return", "false", ";", "}", "string", "restore", "dir", "=", "restore", "field", "get", "text", "(", ")", "trim", "(", ")", ";", "if", "(", "restore", "dir", "=", "=", "null", "|", "|", "restore", "dir", "equals", "(", "\"", "\"", ")", "|", "|", "!", "(", "new", "file", "(", "restore", "dir", ")", ")", "is", "directory", "(", ")", ")", "{", "set", "status", "text", "(", "\"", "specify", "a", "valid", "project", "directory", "\"", ")", ";", "return", "false", ";", "}", "string", "restore", "project", "name", "=", "project", "name", "field", "get", "text", "(", ")", "trim", "(", ")", ";", "if", "(", "restore", "project", "name", "=", "=", "null", "|", "|", "restore", "project", "name", "equals", "(", "\"", "\"", ")", "|", "|", "!", "naming", "utilities", "is", "valid", "name", "(", "restore", "project", "name", ")", ")", "{", "set", "status", "text", "(", "\"", "specify", "a", "valid", "project", "name", "\"", ")", ";", "return", "false", ";", "}", "archive", "path", "name", "=", "archive", "name", ";", "restore", "u", "r", "l", "=", "new", "project", "locator", "(", "restore", "dir", ",", "restore", "project", "name", ")", ";", "file", "proj", "file", "=", "restore", "u", "r", "l", "get", "marker", "file", "(", ")", ";", "file", "proj", "dir", "=", "restore", "u", "r", "l", "get", "project", "dir", "(", ")", ";", "set", "status", "text", "(", "\"", "\"", ")", ";", "if", "(", "proj", "file", "exists", "(", ")", "|", "|", "proj", "dir", "exists", "(", ")", ")", "{", "msg", "show", "info", "(", "get", "class", "(", ")", ",", "get", "component", "(", ")", ",", "\"", "project", "exists", "\"", ",", "\"", "cannot", "restore", "project", "because", "project", "named", "\"", "+", "restore", "project", "name", "+", "\"", "already", "exists", "\"", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}" ]
[ "convert", "a", "namespace", "uri", "and", "dom", "or", "sax", "qualified", "name", "to", "a", "{", "@", "code", "q", "name", "}", "the", "qualified", "name", "can", "have", "the", "form", "{", "@", "code", "prefix", ":", "localname", "}", "or", "{", "@", "code", "local", "name", "}" ]
[ "protected", "q", "name", "to", "q", "name", "(", "string", "namespace", "uri", ",", "string", "qualified", "name", ")", "{", "int", "idx", "=", "qualified", "name", "index", "of", "(", "'", ":", "'", ")", ";", "if", "(", "idx", "=", "=", "-", "1", ")", "{", "return", "new", "q", "name", "(", "namespace", "uri", ",", "qualified", "name", ")", ";", "}", "else", "{", "string", "prefix", "=", "qualified", "name", "substring", "(", "0", ",", "idx", ")", ";", "string", "local", "part", "=", "qualified", "name", "substring", "(", "idx", "+", "1", ")", ";", "return", "new", "q", "name", "(", "namespace", "uri", ",", "local", "part", ",", "prefix", ")", ";", "}", "}" ]
[ "constructs", "a", "new", "parser", "using", "the", "specified", "xml", "file" ]
[ "public", "static", "xml", "pull", "parser", "create", "(", "file", "file", ",", "error", "handler", "err", "handler", ",", "boolean", "validate", ")", "throws", "s", "a", "x", "exception", ",", "i", "o", "exception", "{", "return", "new", "threaded", "xml", "pull", "parser", "impl", "(", "file", ",", "err", "handler", ",", "validate", ",", "1000", ")", ";", "}" ]
[ "tell", "if", "direct", "buffer", "is", "preferred", "or", "not", "it", "'", "s", "for", "callers", "to", "decide", "how", "to", "allocate", "coding", "chunk", "buffers", ",", "using", "direct", "byte", "buffer", "or", "bytes", "array", "it", "will", "return", "false", "by", "default" ]
[ "public", "boolean", "prefer", "direct", "buffer", "(", ")", "{", "return", "false", ";", "}" ]
[ "the", "application", "submission", "context", "for", "this", "{", "@", "link", "r", "m", "app", "}" ]
[ "application", "submission", "context", "get", "application", "submission", "context", "(", ")", ";" ]
[ "resizes", "the", "entries", "storage", "if", "necessary" ]
[ "private", "void", "resize", "me", "maybe", "(", "int", "new", "size", ")", "{", "int", "entries", "size", "=", "entries", "length", ";", "if", "(", "new", "size", ">", "entries", "size", ")", "{", "/", "/", "1", "5x", "but", "round", "up", "to", "nearest", "odd", "(", "this", "is", "optimal", "for", "memory", "consumption", "on", "android", ")", "int", "new", "capacity", "=", "math", "min", "(", "compact", "hashing", "max", "size", ",", "(", "entries", "size", "+", "math", "max", "(", "1", ",", "entries", "size", ">", ">", ">", "1", ")", ")", "|", "1", ")", ";", "if", "(", "new", "capacity", "!", "=", "entries", "size", ")", "{", "resize", "entries", "(", "new", "capacity", ")", ";", "}", "}", "}" ]
[ "start", "of", "the", "document", "generate", "a", "lite", "pal", "attr", "model", "at", "the", "same", "time" ]
[ "public", "void", "start", "document", "(", ")", "throws", "s", "a", "x", "exception", "{", "lite", "pal", "attr", "=", "lite", "pal", "attr", "get", "instance", "(", ")", ";", "lite", "pal", "attr", "get", "class", "names", "(", ")", "clear", "(", ")", ";", "}" ]
[ "clears", "any", "{", "@", "link", "surface", "}", ",", "{", "@", "link", "surface", "holder", "}", ",", "{", "@", "link", "surface", "view", "}", "or", "{", "@", "link", "texture", "view", "}", "currently", "set", "on", "the", "player" ]
[ "void", "clear", "video", "surface", "(", ")", ";" ]
[ "get", "bool", "item" ]
[ "public", "boolean", "get", "bool", "item", "(", ")", "{", "return", "bool", "item", ";", "}" ]
[ "ensure", "get", "default", "port", "(", ")", "returns", "default", "port", "when", "no", "custom", "implementation", "provided" ]
[ "public", "void", "get", "default", "port", "default", "(", ")", "{", "builder", "=", "new", "managed", "channel", "impl", "builder", "(", "dummy", "target", ",", "new", "unsupported", "client", "transport", "factory", "builder", "(", ")", ",", "null", ")", ";", "assert", "equals", "(", "grpc", "util", "default", "port", "ssl", ",", "builder", "get", "default", "port", "(", ")", ")", ";", "}" ]
[ "the", "public", "api", "that", "finds", "the", "nest", "host", "for", "a", "given", "class", "it", "is", "expected", "{", "@", "link", "#", "prepare", "companion", "classes", "(", ")", "}", "executed", "before", "this", "api", "is", "ready", "the", "method", "returns", "{", "@", "link", "optional", "#", "empty", "(", ")", "}", "if", "the", "class", "is", "not", "part", "of", "a", "nest", "a", "generated", "nest", "companion", "class", "and", "its", "nest", "host", "are", "considered", "to", "be", "a", "nest", "hostmember", "relationship" ]
[ "public", "optional", "<", "class", "name", ">", "nest", "host", "(", "class", "name", "class", "name", ")", "{", "/", "/", "ensures", "prepare", "companion", "classes", "has", "been", "executed", "check", "not", "null", "(", "companion", "writers", "(", ")", ")", ";", "return", "nest", "host", "(", "class", "name", ",", "class", "attribute", "record", "(", ")", ",", "nest", "companion", "to", "host", "map", "(", ")", ")", ";", "}" ]
[ "get", "the", "proxy", "-", "mode", "to", "be", "applied", "to", "the", "scoped", "instance" ]
[ "public", "scoped", "proxy", "mode", "get", "scoped", "proxy", "mode", "(", ")", "{", "return", "this", "scoped", "proxy", "mode", ";", "}" ]
[ "find", "the", "fields", "constant", "that", "matches", "name", ",", "or", "null", "if", "its", "not", "found" ]
[ "public", "static", "fields", "find", "by", "name", "(", "string", "name", ")", "{", "return", "by", "name", "get", "(", "name", ")", ";", "}" ]
[ "set", "a", "file", "setting" ]
[ "synchronized", "void", "set", "file", "(", "string", "setting", ",", "byte", "[", "]", "bytes", ")", "{", "ensure", "open", "(", ")", ";", "validate", "setting", "name", "(", "setting", ")", ";", "entry", "old", "entry", "=", "entries", "get", "(", ")", "put", "(", "setting", ",", "new", "entry", "(", "arrays", "copy", "of", "(", "bytes", ",", "bytes", "length", ")", ")", ")", ";", "if", "(", "old", "entry", "!", "=", "null", ")", "{", "arrays", "fill", "(", "old", "entry", "bytes", ",", "(", "byte", ")", "0", ")", ";", "}", "}" ]
[ "returns", "{", "@", "code", "x", "mod", "m", "}", ",", "a", "non", "-", "negative", "value", "less", "than", "{", "@", "code", "m", "}", "this", "differs", "from", "{", "@", "code", "x", "%", "m", "}", ",", "which", "might", "be", "negative", "for", "example", ":", "{", "@", "code", "mod", "(", "7", ",", "4", ")", "=", "=", "3", "mod", "(", "-", "7", ",", "4", ")", "=", "=", "1", "mod", "(", "-", "1", ",", "4", ")", "=", "=", "3", "mod", "(", "-", "8", ",", "4", ")", "=", "=", "0", "mod", "(", "8", ",", "4", ")", "=", "=", "0", "}" ]
[ "public", "static", "long", "mod", "(", "long", "x", ",", "long", "m", ")", "{", "if", "(", "m", "<", "=", "0", ")", "{", "throw", "new", "arithmetic", "exception", "(", "\"", "modulus", "must", "be", "positive", "\"", ")", ";", "}", "long", "result", "=", "x", "%", "m", ";", "return", "(", "result", ">", "=", "0", ")", "?", "result", ":", "result", "+", "m", ";", "}" ]
[ "returns", "the", "extension", "of", "a", "file", "name", "(", "!", "=", "a", "path", ")" ]
[ "protected", "static", "string", "extract", "file", "extension", "(", "string", "file", "name", ")", "{", "check", "not", "null", "(", "file", "name", ")", ";", "int", "last", "period", "index", "=", "file", "name", "last", "index", "of", "(", "'", "'", ")", ";", "if", "(", "last", "period", "index", "<", "0", ")", "{", "return", "null", ";", "}", "else", "{", "return", "file", "name", "substring", "(", "last", "period", "index", "+", "1", ")", ";", "}", "}" ]
[ "{", "@", "inherit", "doc", "}", "the", "default", "{", "@", "link", "abstract", "future", "}", "implementation", "throws", "{", "@", "code", "interrupted", "exception", "}", "if", "the", "current", "thread", "is", "interrupted", "before", "or", "during", "the", "call", ",", "even", "if", "the", "value", "is", "already", "available" ]
[ "public", "v", "get", "(", ")", "throws", "interrupted", "exception", ",", "execution", "exception", "{", "return", "sync", "get", "(", ")", ";", "}" ]
[ "test", "request", "scoped", "caching", "of", "commands", "so", "that", "a", "2nd", "duplicate", "call", "doesn", "'", "t", "execute", "but", "returns", "the", "previous", "future" ]
[ "public", "void", "test", "request", "cache", "1", "(", ")", "{", "final", "test", "collapser", "timer", "timer", "=", "new", "test", "collapser", "timer", "(", ")", ";", "successful", "cacheable", "collapsed", "command", "command", "1", "=", "new", "successful", "cacheable", "collapsed", "command", "(", "timer", ",", "\"", "a", "\"", ",", "true", ")", ";", "successful", "cacheable", "collapsed", "command", "command", "2", "=", "new", "successful", "cacheable", "collapsed", "command", "(", "timer", ",", "\"", "a", "\"", ",", "true", ")", ";", "future", "<", "string", ">", "f", "1", "=", "command", "1", "queue", "(", ")", ";", "future", "<", "string", ">", "f", "2", "=", "command", "2", "queue", "(", ")", ";", "/", "/", "increment", "past", "batch", "time", "so", "it", "executes", "timer", "increment", "time", "(", "15", ")", ";", "try", "{", "assert", "equals", "(", "\"", "a", "\"", ",", "f", "1", "get", "(", "1000", ",", "time", "unit", "milliseconds", ")", ")", ";", "assert", "equals", "(", "\"", "a", "\"", ",", "f", "2", "get", "(", "1000", ",", "time", "unit", "milliseconds", ")", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "throw", "new", "runtime", "exception", "(", "e", ")", ";", "}", "future", "<", "string", ">", "f", "3", "=", "command", "1", "queue", "(", ")", ";", "/", "/", "increment", "past", "batch", "time", "so", "it", "executes", "timer", "increment", "time", "(", "15", ")", ";", "try", "{", "assert", "equals", "(", "\"", "a", "\"", ",", "f", "3", "get", "(", "1000", ",", "time", "unit", "milliseconds", ")", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "throw", "new", "runtime", "exception", "(", "e", ")", ";", "}", "/", "/", "we", "should", "still", "have", "executed", "only", "one", "command", "assert", "equals", "(", "1", ",", "hystrix", "request", "log", "get", "current", "request", "(", ")", "get", "all", "executed", "commands", "(", ")", "size", "(", ")", ")", ";", "hystrix", "invokable", "info", "<", "?", ">", "command", "=", "hystrix", "request", "log", "get", "current", "request", "(", ")", "get", "all", "executed", "commands", "(", ")", "to", "array", "(", "new", "hystrix", "invokable", "info", "<", "?", ">", "[", "1", "]", ")", "[", "0", "]", ";", "system", "out", "println", "(", "\"", "command", "get", "execution", "events", "(", ")", ":", "\"", "+", "command", "get", "execution", "events", "(", ")", ")", ";", "assert", "equals", "(", "2", ",", "command", "get", "execution", "events", "(", ")", "size", "(", ")", ")", ";", "assert", "true", "(", "command", "get", "execution", "events", "(", ")", "contains", "(", "hystrix", "event", "type", "success", ")", ")", ";", "assert", "true", "(", "command", "get", "execution", "events", "(", ")", "contains", "(", "hystrix", "event", "type", "collapsed", ")", ")", ";", "iterator", "<", "hystrix", "invokable", "info", "<", "?", ">", ">", "cmd", "iterator", "=", "hystrix", "request", "log", "get", "current", "request", "(", ")", "get", "all", "executed", "commands", "(", ")", "iterator", "(", ")", ";", "assert", "equals", "(", "1", ",", "cmd", "iterator", "next", "(", ")", "get", "number", "collapsed", "(", ")", ")", ";", "}" ]
[ "checks", "to", "see", "if", "the", "zk", "database", "has", "been", "initialized", "or", "not" ]
[ "public", "boolean", "is", "initialized", "(", ")", "{", "return", "initialized", ";", "}" ]
[ "get", "enum", "string", "required" ]
[ "public", "enum", "string", "required", "enum", "get", "enum", "string", "required", "(", ")", "{", "return", "enum", "string", "required", ";", "}" ]
[ "returns", "the", "string", "representation", "of", "the", "{", "@", "link", "#", "sum", "}" ]
[ "public", "string", "to", "string", "(", ")", "{", "return", "long", "to", "string", "(", "sum", "(", ")", ")", ";", "}" ]
[ "return", "the", "configured", "{", "@", "link", "#", "set", "handle", "ping", "(", "boolean", ")", "}" ]
[ "public", "boolean", "get", "handle", "ping", "(", ")", "{", "return", "get", "websocket", "server", "spec", "(", ")", "handle", "ping", "(", ")", ";", "}" ]
[ "get", "the", "muli", "dex", "{", "@", "link", "shared", "preferences", "}", "for", "the", "current", "application", "should", "be", "called", "only", "while", "owning", "the", "lock", "on", "{", "@", "link", "#", "lock", "filename", "}" ]
[ "private", "static", "shared", "preferences", "get", "multi", "dex", "preferences", "(", "context", "context", ")", "{", "return", "context", "get", "shared", "preferences", "(", "prefs", "file", ",", "build", "version", "sdk", "int", "<", "11", "/", "*", "build", "version", "codes", "honeycomb", "*", "/", "?", "context", "mode", "private", ":", "context", "mode", "private", "|", "0x", "0", "0", "0", "4", "/", "*", "context", "mode", "multi", "process", "*", "/", ")", ";", "}" ]
[ "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", "default", "package", "layout", "pattern", "view", "model", "on", "unbind", "(", "on", "model", "unbound", "listener", "<", "default", "package", "layout", "pattern", "view", "model", ",", "default", "package", "layout", "pattern", "view", ">", "listener", ")", "{", "on", "mutation", "(", ")", ";", "this", "on", "model", "unbound", "listener", "epoxy", "generated", "model", "=", "listener", ";", "return", "this", ";", "}" ]
[ "returns", "the", "{", "@", "link", "com", "google", "devtools", "build", "lib", "analysis", "rule", "error", "consumer", "}", "for", "reporting", "rule", "errors" ]
[ "rule", "error", "consumer", "get", "rule", "error", "consumer", "(", ")", ";" ]
[ "remove", "the", "block", "at", "the", "given", "datanode", "from", "corrupt", "block", "map" ]
[ "boolean", "remove", "from", "corrupt", "replicas", "map", "(", "block", "info", "blk", ",", "datanode", "descriptor", "datanode", ")", "{", "return", "remove", "from", "corrupt", "replicas", "map", "(", "blk", ",", "datanode", ",", "reason", "any", ")", ";", "}" ]