Datasets:
Anonymous2023
/
KGSum

Dataset card Data Studio Files Community
docstring_tokens
list
code_tokens
list
[ "create", "a", "{", "@", "link", "k", "stream", "}", "from", "the", "specified", "topic", "pattern", "the", "default", "{", "@", "code", "\"", "auto", "offset", "reset", "\"", "}", "strategy", ",", "default", "{", "@", "link", "timestamp", "extractor", "}", ",", "and", "default", "key", "and", "value", "deserializers", "as", "specified", "in", "the", "{", "@", "link", "streams", "config", "config", "}", "are", "used", "if", "multiple", "topics", "are", "matched", "by", "the", "specified", "pattern", ",", "the", "created", "{", "@", "link", "k", "stream", "}", "will", "read", "data", "from", "all", "of", "them", "and", "there", "is", "no", "ordering", "guarantee", "between", "records", "from", "different", "topics", "this", "also", "means", "that", "the", "work", "will", "not", "be", "parallelized", "for", "multiple", "topics", ",", "and", "the", "number", "of", "tasks", "will", "scale", "with", "the", "maximum", "partition", "count", "of", "any", "matching", "topic", "rather", "than", "the", "total", "number", "of", "partitions", "across", "all", "topics", "note", "that", "the", "specified", "input", "topics", "must", "be", "partitioned", "by", "key", "if", "this", "is", "not", "the", "case", "it", "is", "the", "user", "'", "s", "responsibility", "to", "repartition", "the", "data", "before", "any", "key", "based", "operation", "(", "like", "aggregation", "or", "join", ")", "is", "applied", "to", "the", "returned", "{", "@", "link", "k", "stream", "}" ]
[ "public", "synchronized", "<", "k", ",", "v", ">", "k", "stream", "<", "k", ",", "v", ">", "stream", "(", "final", "pattern", "topic", "pattern", ")", "{", "return", "stream", "(", "topic", "pattern", ",", "consumed", "with", "(", "null", ",", "null", ")", ")", ";", "}" ]
[ "initialization", "method", "for", "the", "schema", "it", "is", "called", "before", "the", "actual", "working", "methods", "{", "@", "link", "#", "serialize", "(", "object", ",", "long", ")", "}", "and", "thus", "suitable", "for", "one", "time", "setup", "work", "the", "provided", "{", "@", "link", "serialization", "schema", "initialization", "context", "}", "can", "be", "used", "to", "access", "additional", "features", "such", "as", "e", "g", "registering", "user", "metrics" ]
[ "default", "void", "open", "(", "serialization", "schema", "initialization", "context", "context", ")", "throws", "exception", "{", "}" ]
[ "checks", "if", "the", "given", "data", "is", "known" ]
[ "public", "static", "boolean", "is", "known", "data", "(", "string", "data", ",", "string", "[", "]", "known", "words", ")", "{", "/", "/", "check", "if", "the", "data", "is", "known", "content", "/", "/", "todo", "[", "chunking", "]", "do", "this", "for", "sub", "-", "strings", "of", "data", "for", "(", "string", "kd", ":", "known", "words", ")", "{", "if", "(", "data", "equals", "(", "kd", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]
[ "set", "sentinel", "host", "and", "master", "id", "creates", "a", "new", "builder" ]
[ "public", "static", "redis", "connection", "config", "builder", "redis", "sentinel", "(", "string", "host", ",", "string", "master", "id", ")", "{", "return", "redis", "sentinel", "(", "host", ",", "default", "sentinel", "port", ",", "master", "id", ")", ";", "}" ]
[ "test", "the", "property", "'", "name", "'" ]
[ "public", "void", "name", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "name", "}" ]
[ "returns", "an", "immutable", "array", "containing", "the", "given", "values", ",", "in", "order" ]
[ "public", "static", "immutable", "double", "array", "copy", "of", "(", "collection", "<", "double", ">", "values", ")", "{", "return", "values", "is", "empty", "(", ")", "?", "empty", ":", "new", "immutable", "double", "array", "(", "doubles", "to", "array", "(", "values", ")", ")", ";", "}" ]
[ "plays", "a", "random", "track" ]
[ "public", "void", "play", "random", "(", ")", "{", "if", "(", "is", "dark", "(", ")", ")", "{", "play", "once", "(", "dark", "music", "random", "(", "last", "random", "played", ")", ")", ";", "}", "else", "{", "play", "once", "(", "ambient", "music", "random", "(", "last", "random", "played", ")", ")", ";", "}", "}" ]
[ "print", "something", "to", "stderr" ]
[ "private", "static", "void", "err", "(", "string", "s", ",", "object", "args", ")", "{", "stderr", "format", "(", "s", ",", "args", ")", ";", "stderr", "print", "(", "'", "\\", "n", "'", ")", ";", "}" ]
[ "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", "\"", ")", ";", "}" ]
[ "configure", "the", "complete", "list", "of", "supported", "argument", "types", ",", "effectively", "overriding", "the", "ones", "configured", "by", "default", "this", "is", "an", "advanced", "option", ";", "for", "most", "use", "cases", "it", "should", "be", "sufficient", "to", "use", "{", "@", "link", "#", "set", "custom", "argument", "resolvers", "}" ]
[ "public", "void", "set", "argument", "resolvers", "(", "@", "nullable", "list", "<", "handler", "method", "argument", "resolver", ">", "argument", "resolvers", ")", "{", "if", "(", "argument", "resolvers", "=", "=", "null", ")", "{", "this", "argument", "resolvers", "clear", "(", ")", ";", "return", ";", "}", "this", "argument", "resolvers", "add", "resolvers", "(", "argument", "resolvers", ")", ";", "}" ]
[ "gets", "the", "number", "of", "locals" ]
[ "public", "int", "get", "max", "locals", "(", ")", "{", "return", "max", "locals", ";", "}" ]
[ "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", ")", ";", "}" ]
[ "clean", "the", "repository" ]
[ "public", "void", "clean", "(", ")", "{", "val", "now", "=", "zoned", "date", "time", "now", "(", "zone", "id", "system", "default", "(", ")", ")", ";", "logger", "debug", "(", "\"", "starting", "to", "clean", "previously", "used", "authenticator", "tokens", "from", "[", "{", "}", "]", "at", "[", "{", "}", "]", "\"", ",", "this", "token", "repository", ",", "now", ")", ";", "token", "repository", "clean", "(", ")", ";", "logger", "debug", "(", "\"", "finished", "cleaning", "authenticator", "tokens", "at", "[", "{", "}", "]", "\"", ",", "now", ")", ";", "}" ]
[ "delete", "a", "bookmark", "type" ]
[ "void", "delete", "record", "(", "long", "type", "id", ")", "throws", "i", "o", "exception", "{", "throw", "new", "unsupported", "operation", "exception", "(", "\"", "bookmarks", "are", "read", "-", "only", "and", "may", "not", "be", "deleted", "\"", ")", ";", "}" ]
[ "implementations", "of", "this", "method", "reverse", "the", "data", "masking", "process", "applied", "to", "a", "qr", "code", "and", "make", "its", "bits", "ready", "to", "read" ]
[ "final", "void", "unmask", "bit", "matrix", "(", "bit", "matrix", "bits", ",", "int", "dimension", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "dimension", ";", "i", "+", "+", ")", "{", "for", "(", "int", "j", "=", "0", ";", "j", "<", "dimension", ";", "j", "+", "+", ")", "{", "if", "(", "is", "masked", "(", "i", ",", "j", ")", ")", "{", "bits", "flip", "(", "j", ",", "i", ")", ";", "}", "}", "}", "}" ]
[ "get", "or", "create", "a", "sensor", "with", "the", "given", "unique", "name", "and", "zero", "or", "more", "parent", "sensors", "all", "parent", "sensors", "will", "receive", "every", "value", "recorded", "with", "this", "sensor" ]
[ "public", "synchronized", "sensor", "sensor", "(", "string", "name", ",", "metric", "config", "config", ",", "sensor", "recording", "level", "recording", "level", ",", "sensor", "parents", ")", "{", "return", "sensor", "(", "name", ",", "config", ",", "long", "max", "value", ",", "recording", "level", ",", "parents", ")", ";", "}" ]
[ "this", "test", "makes", "sure", "that", "the", "checkpoint", "is", "already", "registered", "by", "the", "time", "that", "the", "hooks", "are", "called" ]
[ "public", "void", "ensure", "registered", "at", "hook", "time", "(", ")", "throws", "exception", "{", "final", "string", "id", "=", "\"", "id", "\"", ";", "/", "/", "create", "the", "checkpoint", "coordinator", "final", "job", "i", "d", "jid", "=", "new", "job", "i", "d", "(", ")", ";", "final", "execution", "attempt", "i", "d", "exec", "id", "=", "new", "execution", "attempt", "i", "d", "(", ")", ";", "final", "execution", "vertex", "ack", "vertex", "=", "mock", "execution", "vertex", "(", "exec", "id", ")", ";", "final", "manually", "triggered", "scheduled", "executor", "manually", "triggered", "scheduled", "executor", "=", "new", "manually", "triggered", "scheduled", "executor", "(", ")", ";", "final", "checkpoint", "coordinator", "cc", "=", "instantiate", "checkpoint", "coordinator", "(", "jid", ",", "manually", "triggered", "scheduled", "executor", ",", "ack", "vertex", ")", ";", "final", "master", "trigger", "restore", "hook", "<", "void", ">", "hook", "=", "mock", "generic", "(", "master", "trigger", "restore", "hook", "class", ")", ";", "when", "(", "hook", "get", "identifier", "(", ")", ")", "then", "return", "(", "id", ")", ";", "when", "(", "hook", "trigger", "checkpoint", "(", "any", "long", "(", ")", ",", "any", "long", "(", ")", ",", "any", "(", "executor", "class", ")", ")", ")", "then", "answer", "(", "new", "answer", "<", "completable", "future", "<", "void", ">", ">", "(", ")", "{", "@", "override", "public", "completable", "future", "<", "void", ">", "answer", "(", "invocation", "on", "mock", "invocation", ")", "throws", "throwable", "{", "assert", "equals", "(", "1", ",", "cc", "get", "number", "of", "pending", "checkpoints", "(", ")", ")", ";", "long", "checkpoint", "id", "=", "(", "long", ")", "invocation", "get", "arguments", "(", ")", "[", "0", "]", ";", "assert", "not", "null", "(", "cc", "get", "pending", "checkpoints", "(", ")", "get", "(", "checkpoint", "id", ")", ")", ";", "return", "null", ";", "}", "}", ")", ";", "cc", "add", "master", "hook", "(", "hook", ")", ";", "/", "/", "trigger", "a", "checkpoint", "final", "completable", "future", "<", "completed", "checkpoint", ">", "checkpoint", "future", "=", "cc", "trigger", "checkpoint", "(", "false", ")", ";", "manually", "triggered", "scheduled", "executor", "trigger", "all", "(", ")", ";", "assert", "false", "(", "checkpoint", "future", "is", "completed", "exceptionally", "(", ")", ")", ";", "}" ]
[ "check", "that", "we", "can", "get", "the", "factory", "bean", "itself", "this", "is", "only", "possible", "if", "we", "'", "re", "dealing", "with", "a", "factory" ]
[ "public", "void", "get", "factory", "itself", "(", ")", "throws", "exception", "{", "assert", "that", "(", "get", "bean", "factory", "(", ")", "get", "bean", "(", "\"", "&", "singleton", "factory", "\"", ")", ")", "is", "not", "null", "(", ")", ";", "}" ]
[ "char", "argument", "that", "matches", "any", "of", "the", "given", "argument", "matchers", "see", "examples", "in", "javadoc", "for", "{", "@", "link", "additional", "matchers", "}", "class" ]
[ "public", "static", "char", "or", "(", "char", "first", ",", "char", "second", ")", "{", "mocking", "progress", "(", ")", "get", "argument", "matcher", "storage", "(", ")", "report", "or", "(", ")", ";", "return", "0", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "string", "to", "string", "(", ")", "{", "return", "\"", "known", "-", "null", "\"", ";", "}" ]
[ "return", "the", "number", "of", "free", "bytes", "in", "the", "chunk" ]
[ "int", "free", "bytes", "(", ")", ";" ]
[ "user", "who", "has", "started", "the", "zoo", "keeper", "server", "user", ",", "it", "will", "be", "the", "logged", "-", "in", "user", "if", "no", "user", "logged", "-", "in", "then", "system", "user" ]
[ "public", "static", "string", "get", "user", "name", "(", ")", "{", "return", "login", "user", ";", "}" ]
[ "returns", "the", "total", "number", "of", "uncompressed", "bytes", "input", "so", "far" ]
[ "public", "long", "get", "bytes", "read", "(", ")", "{", "check", "stream", "(", ")", ";", "return", "bytes", "read", ";", "}" ]
[ "parse", "target", "string", "as", "key", "-", "value", "string", "and", "return", "the", "value", "matches", "key", "name", "if", "accept", "any", "null", "arguments", ",", "return", "null", "example", ":", "keyvalue", "(", "'", "k", "1", "=", "v", "1", ";", "k", "2", "=", "v", "2", "'", ",", "'", ";", "'", ",", "'", "=", "'", ",", "'", "k", "2", "'", ")", "=", "'", "v", "2", "'", "keyvalue", "(", "'", "k", "1", ":", "v", "1", ",", "k", "2", ":", "v", "2", "'", ",", "'", ",", "'", ",", "'", ":", "'", ",", "'", "k", "3", "'", ")", "=", "null" ]
[ "public", "static", "binary", "string", "data", "key", "value", "(", "binary", "string", "data", "str", ",", "byte", "split", "1", ",", "byte", "split", "2", ",", "binary", "string", "data", "key", "name", ")", "{", "str", "ensure", "materialized", "(", ")", ";", "if", "(", "key", "name", "=", "=", "null", "|", "|", "key", "name", "get", "size", "in", "bytes", "(", ")", "=", "=", "0", ")", "{", "return", "null", ";", "}", "if", "(", "str", "in", "first", "segment", "(", ")", "&", "&", "key", "name", "in", "first", "segment", "(", ")", ")", "{", "/", "/", "position", "in", "byte", "int", "byte", "idx", "=", "0", ";", "/", "/", "position", "of", "last", "split", "1", "int", "last", "split", "1", "idx", "=", "-", "1", ";", "while", "(", "byte", "idx", "<", "str", "get", "size", "in", "bytes", "(", ")", ")", "{", "/", "/", "if", "find", "next", "split", "1", "in", "str", ",", "process", "current", "kv", "if", "(", "str", "get", "segments", "(", ")", "[", "0", "]", "get", "(", "str", "get", "offset", "(", ")", "+", "byte", "idx", ")", "=", "=", "split", "1", ")", "{", "int", "current", "key", "idx", "=", "last", "split", "1", "idx", "+", "1", ";", "/", "/", "if", "key", "of", "current", "kv", "is", "key", "name", ",", "return", "the", "value", "directly", "binary", "string", "data", "value", "=", "find", "value", "of", "key", "(", "str", ",", "split", "2", ",", "key", "name", ",", "current", "key", "idx", ",", "byte", "idx", ")", ";", "if", "(", "value", "!", "=", "null", ")", "{", "return", "value", ";", "}", "last", "split", "1", "idx", "=", "byte", "idx", ";", "}", "byte", "idx", "+", "+", ";", "}", "/", "/", "process", "the", "string", "which", "is", "not", "ends", "with", "split", "1", "int", "current", "key", "idx", "=", "last", "split", "1", "idx", "+", "1", ";", "return", "find", "value", "of", "key", "(", "str", ",", "split", "2", ",", "key", "name", ",", "current", "key", "idx", ",", "str", "get", "size", "in", "bytes", "(", ")", ")", ";", "}", "else", "{", "return", "key", "value", "slow", "(", "str", ",", "split", "1", ",", "split", "2", ",", "key", "name", ")", ";", "}", "}" ]
[ "blocks", "until", "{", "@", "link", "block", "manager", "#", "redundancy", "monitor", "}", "daemon", "completes", "a", "full", "iteration" ]
[ "protected", "void", "wait", "for", "redundancy", "monitor", "cycle", "(", ")", "throws", "timeout", "exception", ",", "interrupted", "exception", "{", "/", "/", "wait", "for", "the", "redundancy", "monitor", "to", "mark", "the", "file", "as", "corrupt", "final", "block", "manager", "bm", "=", "cluster", "get", "namesystem", "(", ")", "get", "block", "manager", "(", ")", ";", "final", "long", "last", "redundancy", "t", "s", "=", "bm", "get", "last", "redundancy", "monitor", "t", "s", "(", ")", ";", "generic", "test", "utils", "wait", "for", "(", "(", ")", "-", ">", "last", "redundancy", "t", "s", "!", "=", "bm", "get", "last", "redundancy", "monitor", "t", "s", "(", ")", ",", "2", "*", "wait", "poll", "interval", "large", "ms", ",", "wait", "for", "redundancy", "ms", ")", ";", "}" ]
[ "remove", "mount", "table", "entry", "api", "should", "internally", "update", "the", "cache", "on", "all", "the", "routers" ]
[ "public", "void", "test", "mount", "table", "entries", "cache", "updated", "after", "remove", "a", "p", "i", "call", "(", ")", "throws", "i", "o", "exception", "{", "/", "/", "add", "string", "src", "path", "=", "\"", "/", "remove", "path", "src", "\"", ";", "mount", "table", "new", "entry", "=", "mount", "table", "new", "instance", "(", "src", "path", ",", "collections", "singleton", "map", "(", "\"", "ns", "0", "\"", ",", "\"", "/", "remove", "path", "dest", "\"", ")", ",", "time", "now", "(", ")", ",", "time", "now", "(", ")", ")", ";", "add", "mount", "table", "entry", "(", "mount", "table", "manager", ",", "new", "entry", ")", ";", "/", "/", "when", "add", "entry", "is", "done", ",", "all", "the", "routers", "must", "have", "updated", "its", "mount", "/", "/", "table", "entry", "list", "<", "router", "context", ">", "routers", "=", "get", "routers", "(", ")", ";", "for", "(", "router", "context", "rc", ":", "routers", ")", "{", "list", "<", "mount", "table", ">", "result", "=", "get", "mount", "table", "entries", "(", "rc", "get", "admin", "client", "(", ")", "get", "mount", "table", "manager", "(", ")", ")", ";", "assert", "equals", "(", "1", ",", "result", "size", "(", ")", ")", ";", "mount", "table", "mount", "table", "result", "=", "result", "get", "(", "0", ")", ";", "assert", "equals", "(", "src", "path", ",", "mount", "table", "result", "get", "source", "path", "(", ")", ")", ";", "}", "/", "/", "remove", "remove", "mount", "table", "entry", "response", "remove", "mount", "table", "entry", "=", "mount", "table", "manager", "remove", "mount", "table", "entry", "(", "remove", "mount", "table", "entry", "request", "new", "instance", "(", "src", "path", ")", ")", ";", "assert", "true", "(", "remove", "mount", "table", "entry", "get", "status", "(", ")", ")", ";", "/", "/", "when", "remove", "entry", "is", "done", ",", "all", "the", "routers", "must", "have", "removed", "its", "mount", "/", "/", "table", "entry", "routers", "=", "get", "routers", "(", ")", ";", "for", "(", "router", "context", "rc", ":", "routers", ")", "{", "list", "<", "mount", "table", ">", "result", "=", "get", "mount", "table", "entries", "(", "rc", "get", "admin", "client", "(", ")", "get", "mount", "table", "manager", "(", ")", ")", ";", "assert", "equals", "(", "0", ",", "result", "size", "(", ")", ")", ";", "}", "}" ]
[ "visit", "any", "type", "of", "attribute" ]
[ "public", "void", "visit", "any", "attribute", "(", "clazz", "clazz", ",", "attribute", "attribute", ")", "{", "throw", "new", "unsupported", "operation", "exception", "(", "\"", "method", "must", "be", "overridden", "in", "[", "\"", "+", "this", "get", "class", "(", ")", "get", "name", "(", ")", "+", "\"", "]", "if", "ever", "called", "\"", ")", ";", "}" ]
[ "ensures", "that", "an", "object", "reference", "passed", "as", "a", "parameter", "to", "the", "calling", "method", "is", "not", "null", "see", "{", "@", "link", "#", "check", "not", "null", "(", "object", ",", "string", ",", "object", ")", "}", "for", "details" ]
[ "public", "static", "<", "t", "extends", "object", ">", "t", "check", "not", "null", "(", "@", "non", "null", "decl", "t", "obj", ",", "@", "nullable", "decl", "string", "error", "message", "template", ",", "@", "nullable", "decl", "object", "p", "1", ",", "@", "nullable", "decl", "object", "p", "2", ")", "{", "if", "(", "obj", "=", "=", "null", ")", "{", "throw", "new", "null", "pointer", "exception", "(", "lenient", "format", "(", "error", "message", "template", ",", "p", "1", ",", "p", "2", ")", ")", ";", "}", "return", "obj", ";", "}" ]
[ "get", "the", "next", "{", "@", "link", "history", "event", "}" ]
[ "history", "event", "next", "event", "(", ")", "throws", "i", "o", "exception", ";" ]
[ "add", "a", "default", "header" ]
[ "public", "api", "client", "add", "default", "header", "(", "string", "name", ",", "string", "value", ")", "{", "if", "(", "default", "headers", "contains", "key", "(", "name", ")", ")", "{", "default", "headers", "remove", "(", "name", ")", ";", "}", "default", "headers", "add", "(", "name", ",", "value", ")", ";", "return", "this", ";", "}" ]
[ "return", "the", "{", "@", "link", "environment", "}", "for", "which", "the", "current", "application", "is", "running" ]
[ "environment", "get", "environment", "(", ")", ";" ]
[ "test", "the", "property", "'", "byte", "'" ]
[ "public", "void", "byte", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "byte", "}" ]
[ "verify", "storage", "policies", "are", "enabled", "and", "if", "only", "super", "user", "is", "allowed", "to", "set", "storage", "policies" ]
[ "private", "void", "check", "storage", "policy", "enabled", "(", "final", "string", "operation", "name", "readable", ",", "boolean", "check", "super", "user", ")", "throws", "i", "o", "exception", "{", "if", "(", "!", "is", "storage", "policy", "enabled", ")", "{", "throw", "new", "i", "o", "exception", "(", "string", "format", "(", "\"", "failed", "to", "%", "s", "since", "%", "s", "is", "set", "to", "false", "\"", ",", "operation", "name", "readable", ",", "dfs", "storage", "policy", "enabled", "key", ")", ")", ";", "}", "if", "(", "check", "super", "user", "&", "&", "is", "storage", "policy", "superuser", "only", ")", "{", "check", "superuser", "privilege", "(", "case", "utils", "to", "camel", "case", "(", "operation", "name", "readable", ",", "false", ")", ")", ";", "}", "}" ]
[ "mark", "the", "given", "shards", "as", "started", ",", "then", "perform", "a", "reroute", "(", "which", "may", "start", "some", "other", "shards", "initializing", ")" ]
[ "public", "static", "cluster", "state", "start", "shards", "and", "reroute", "(", "allocation", "service", "allocation", "service", ",", "cluster", "state", "cluster", "state", ",", "shard", "routing", "initializing", "shards", ")", "{", "return", "start", "shards", "and", "reroute", "(", "allocation", "service", ",", "cluster", "state", ",", "arrays", "as", "list", "(", "initializing", "shards", ")", ")", ";", "}" ]
[ "return", "the", "number", "of", "keyvalue", "pairs", "stored", "in", "the", "hashtable" ]
[ "public", "int", "size", "(", ")", "{", "return", "indexer", "get", "size", "(", ")", ";", "}" ]
[ "perform", "spring", "-", "based", "scanning", "for", "entity", "classes" ]
[ "private", "spring", "persistence", "unit", "info", "build", "default", "persistence", "unit", "info", "(", ")", "{", "spring", "persistence", "unit", "info", "scanned", "unit", "=", "new", "spring", "persistence", "unit", "info", "(", ")", ";", "if", "(", "this", "default", "persistence", "unit", "name", "!", "=", "null", ")", "{", "scanned", "unit", "set", "persistence", "unit", "name", "(", "this", "default", "persistence", "unit", "name", ")", ";", "}", "scanned", "unit", "set", "exclude", "unlisted", "classes", "(", "true", ")", ";", "if", "(", "this", "packages", "to", "scan", "!", "=", "null", ")", "{", "for", "(", "string", "pkg", ":", "this", "packages", "to", "scan", ")", "{", "scan", "package", "(", "scanned", "unit", ",", "pkg", ")", ";", "}", "}", "if", "(", "this", "mapping", "resources", "!", "=", "null", ")", "{", "for", "(", "string", "mapping", "file", "name", ":", "this", "mapping", "resources", ")", "{", "scanned", "unit", "add", "mapping", "file", "name", "(", "mapping", "file", "name", ")", ";", "}", "}", "else", "{", "resource", "orm", "xml", "=", "get", "orm", "xml", "for", "default", "persistence", "unit", "(", ")", ";", "if", "(", "orm", "xml", "!", "=", "null", ")", "{", "scanned", "unit", "add", "mapping", "file", "name", "(", "default", "orm", "xml", "resource", ")", ";", "if", "(", "scanned", "unit", "get", "persistence", "unit", "root", "url", "(", ")", "=", "=", "null", ")", "{", "try", "{", "scanned", "unit", "set", "persistence", "unit", "root", "url", "(", "persistence", "unit", "reader", "determine", "persistence", "unit", "root", "url", "(", "orm", "xml", ")", ")", ";", "}", "catch", "(", "i", "o", "exception", "ex", ")", "{", "logger", "debug", "(", "\"", "failed", "to", "determine", "persistence", "unit", "root", "url", "from", "orm", "xml", "location", "\"", ",", "ex", ")", ";", "}", "}", "}", "}", "return", "scanned", "unit", ";", "}" ]
[ "returns", "true", "if", "the", "operation", "could", "be", "successful", "if", "forced" ]
[ "public", "boolean", "can", "force", "(", ")", "{", "return", "can", "force", ";", "}" ]
[ "set", "the", "total", "count", "of", "all", "of", "the", "parameters", "in", "the", "sql", "statement", "repeated", "occurrences", "of", "the", "same", "parameter", "name", "do", "count", "here" ]
[ "void", "set", "total", "parameter", "count", "(", "int", "total", "parameter", "count", ")", "{", "this", "total", "parameter", "count", "=", "total", "parameter", "count", ";", "}" ]
[ "closing", "the", "block", "will", "release", "the", "buffer" ]
[ "protected", "void", "inner", "close", "(", ")", "{", "if", "(", "block", "buffer", "!", "=", "null", ")", "{", "block", "released", "(", ")", ";", "release", "buffer", "(", "block", "buffer", ")", ";", "block", "buffer", "=", "null", ";", "}", "}" ]
[ "invalidate", "the", "active", "keystore", "and", "key", "manager" ]
[ "private", "synchronized", "void", "invalidate", "key", "(", ")", "{", "wrapped", "key", "manager", "=", "null", ";", "keystore", "path", "=", "null", ";", "is", "self", "signed", "=", "false", ";", "}" ]
[ "process", "the", "bytes", "received", "from", "the", "peer" ]
[ "public", "boolean", "process", "bytes", "from", "peer", "(", "byte", "buffer", "bytes", ")", "throws", "general", "security", "exception", "{", "/", "/", "if", "we", "'", "re", "the", "client", "and", "we", "haven", "'", "t", "given", "an", "output", "frame", ",", "we", "shouldn", "'", "t", "be", "processing", "any", "/", "/", "bytes", "if", "(", "output", "frame", "=", "=", "null", "&", "&", "is", "client", ")", "{", "return", "true", ";", "}", "/", "/", "if", "we", "already", "have", "bytes", "to", "write", ",", "just", "return", "if", "(", "output", "frame", "!", "=", "null", "&", "&", "output", "frame", "has", "remaining", "(", ")", ")", "{", "return", "true", ";", "}", "int", "remaining", "=", "bytes", "remaining", "(", ")", ";", "/", "/", "call", "handshaker", "service", "to", "proceess", "the", "bytes", "if", "(", "output", "frame", "=", "=", "null", ")", "{", "check", "state", "(", "!", "is", "client", ",", "\"", "client", "handshaker", "should", "not", "process", "any", "frame", "at", "the", "beginning", "\"", ")", ";", "output", "frame", "=", "handshaker", "start", "server", "handshake", "(", "bytes", ")", ";", "}", "else", "{", "output", "frame", "=", "handshaker", "next", "(", "bytes", ")", ";", "}", "/", "/", "if", "handshake", "has", "finished", "or", "we", "already", "have", "bytes", "to", "write", ",", "just", "return", "true", "if", "(", "handshaker", "is", "finished", "(", ")", "|", "|", "output", "frame", "has", "remaining", "(", ")", ")", "{", "return", "true", ";", "}", "/", "/", "we", "have", "done", "processing", "input", "bytes", ",", "but", "no", "bytes", "to", "write", "thus", "we", "need", "more", "data", "if", "(", "!", "bytes", "has", "remaining", "(", ")", ")", "{", "return", "false", ";", "}", "/", "/", "there", "are", "still", "remaining", "bytes", "thus", "we", "need", "to", "continue", "processing", "the", "bytes", "/", "/", "prevent", "infinite", "loop", "by", "checking", "some", "bytes", "are", "consumed", "by", "handshaker", "check", "state", "(", "bytes", "remaining", "(", ")", "<", "remaining", ",", "\"", "handshaker", "did", "not", "consume", "any", "bytes", "\"", ")", ";", "return", "process", "bytes", "from", "peer", "(", "bytes", ")", ";", "}" ]
[ "indicate", "whether", "dtd", "parsing", "should", "be", "supported", "default", "is", "{", "@", "code", "false", "}", "meaning", "that", "dtd", "is", "disabled" ]
[ "public", "void", "set", "support", "dtd", "(", "boolean", "support", "dtd", ")", "{", "this", "support", "dtd", "=", "support", "dtd", ";", "}" ]
[ "all", "data", "sources", "failed", ",", "second", "data", "source", "produced", "multiple", "intermediate", "results" ]
[ "public", "void", "test", "lifecycle", "f1", "i2", "i2", "f2", "f3", "c", "(", ")", "{", "data", "source", "<", "object", ">", "data", "source", "=", "get", "and", "subscribe", "(", ")", ";", "data", "subscriber", "<", "object", ">", "subscriber", "1", "=", "verify", "get", "and", "subscribe", "(", "m", "data", "source", "supplier", "1", ",", "m", "src", "1", ")", ";", "set", "state", "(", "m", "src", "1", ",", "not", "closed", ",", "finished", ",", "without", "result", ",", "null", ",", "failed", ",", "mock", "(", "throwable", "class", ")", ")", ";", "subscriber", "1", "on", "failure", "(", "m", "src", "1", ")", ";", "m", "in", "order", "verify", "(", "m", "src", "1", ")", "close", "(", ")", ";", "data", "subscriber", "<", "object", ">", "subscriber", "2", "=", "verify", "get", "and", "subscribe", "(", "m", "data", "source", "supplier", "2", ",", "m", "src", "2", ")", ";", "verify", "state", "(", "data", "source", ",", "null", ",", "not", "closed", ",", "not", "finished", ",", "without", "result", ",", "null", ",", "not", "failed", ",", "null", ")", ";", "object", "val", "2a", "=", "mock", "(", "object", "class", ")", ";", "set", "state", "(", "m", "src", "2", ",", "not", "closed", ",", "not", "finished", ",", "with", "result", ",", "val", "2a", ",", "not", "failed", ",", "null", ")", ";", "subscriber", "2", "on", "new", "result", "(", "m", "src", "2", ")", ";", "verify", "subscriber", "(", "data", "source", ",", "m", "src", "2", ",", "on", "new", "result", ")", ";", "verify", "state", "(", "data", "source", ",", "m", "src", "2", ",", "not", "closed", ",", "not", "finished", ",", "with", "result", ",", "val", "2a", ",", "not", "failed", ",", "null", ")", ";", "object", "val", "2b", "=", "mock", "(", "object", "class", ")", ";", "set", "state", "(", "m", "src", "2", ",", "not", "closed", ",", "not", "finished", ",", "with", "result", ",", "val", "2b", ",", "not", "failed", ",", "null", ")", ";", "subscriber", "2", "on", "new", "result", "(", "m", "src", "2", ")", ";", "verify", "subscriber", "(", "data", "source", ",", "m", "src", "2", ",", "on", "new", "result", ")", ";", "verify", "state", "(", "data", "source", ",", "m", "src", "2", ",", "not", "closed", ",", "not", "finished", ",", "with", "result", ",", "val", "2b", ",", "not", "failed", ",", "null", ")", ";", "set", "state", "(", "m", "src", "2", ",", "not", "closed", ",", "finished", ",", "with", "result", ",", "val", "2b", ",", "failed", ",", "mock", "(", "throwable", "class", ")", ")", ";", "subscriber", "2", "on", "failure", "(", "m", "src", "2", ")", ";", "data", "subscriber", "<", "object", ">", "subscriber", "3", "=", "verify", "get", "and", "subscribe", "(", "m", "data", "source", "supplier", "3", ",", "m", "src", "3", ")", ";", "verify", "state", "(", "data", "source", ",", "m", "src", "2", ",", "not", "closed", ",", "not", "finished", ",", "with", "result", ",", "val", "2b", ",", "not", "failed", ",", "null", ")", ";", "throwable", "throwable", "=", "mock", "(", "throwable", "class", ")", ";", "set", "state", "(", "m", "src", "3", ",", "not", "closed", ",", "finished", ",", "without", "result", ",", "null", ",", "failed", ",", "throwable", ")", ";", "subscriber", "3", "on", "failure", "(", "m", "src", "3", ")", ";", "m", "in", "order", "verify", "(", "m", "src", "3", ")", "close", "(", ")", ";", "verify", "subscriber", "(", "data", "source", ",", "m", "src", "3", ",", "on", "failure", ")", ";", "verify", "state", "(", "data", "source", ",", "m", "src", "2", ",", "not", "closed", ",", "finished", ",", "with", "result", ",", "val", "2b", ",", "failed", ",", "throwable", ")", ";", "test", "close", "(", "data", "source", ",", "m", "src", "2", ")", ";", "verify", "state", "(", "data", "source", ",", "null", ",", "closed", ",", "finished", ",", "without", "result", ",", "null", ",", "failed", ",", "throwable", ")", ";", "}" ]
[ "sets", "the", "postprocessor" ]
[ "public", "image", "request", "builder", "set", "postprocessor", "(", "@", "nullable", "postprocessor", "postprocessor", ")", "{", "m", "postprocessor", "=", "postprocessor", ";", "return", "this", ";", "}" ]
[ "get", "the", "underlying", "buffer", "backing", "this", "record", "instance" ]
[ "public", "byte", "buffer", "buffer", "(", ")", "{", "return", "this", "buffer", ";", "}" ]
[ "checks", "and", "throws", "an", "{", "@", "link", "illegal", "state", "exception", "}", "if", "an", "error", "was", "previously", "set", "on", "this", "instance", "via", "{", "@", "link", "#", "on", "error", "}" ]
[ "public", "void", "maybe", "throw", "media", "codec", "exception", "(", ")", "throws", "illegal", "state", "exception", "{", "illegal", "state", "exception", "exception", "=", "media", "codec", "exception", ";", "media", "codec", "exception", "=", "null", ";", "if", "(", "exception", "!", "=", "null", ")", "{", "throw", "exception", ";", "}", "}" ]
[ "returns", "the", "{", "@", "link", "tool", "association", "info", "associations", "}", ",", "which", "describe", "content", "types", "and", "the", "tools", "used", "to", "open", "them", ",", "for", "all", "content", "types", "known", "to", "the", "system" ]
[ "public", "set", "<", "tool", "association", "info", ">", "get", "content", "type", "tool", "associations", "(", ")", ";" ]
[ "test", "the", "property", "'", "indirect", "map", "'" ]
[ "public", "void", "indirect", "map", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "indirect", "map", "}" ]
[ "extract", "the", "configuration", "from", "the", "nominated", "{", "@", "link", "caching", "configurer", "}" ]
[ "protected", "void", "use", "caching", "configurer", "(", "caching", "configurer", "config", ")", "{", "this", "cache", "manager", "=", "config", ":", ":", "cache", "manager", ";", "this", "cache", "resolver", "=", "config", ":", ":", "cache", "resolver", ";", "this", "key", "generator", "=", "config", ":", ":", "key", "generator", ";", "this", "error", "handler", "=", "config", ":", ":", "error", "handler", ";", "}" ]
[ "calculates", "the", "n", "-", "degree", "b", "-", "spline", "value", "for", "the", "given", "span", "(", "i", ")", "at", "the", "given", "position", "(", "u", ")" ]
[ "public", "static", "<", "t", "extends", "vector", "<", "t", ">", ">", "t", "calculate", "(", "final", "t", "out", ",", "final", "int", "i", ",", "final", "float", "u", ",", "final", "t", "[", "]", "points", ",", "final", "int", "degree", ",", "final", "boolean", "continuous", ",", "final", "t", "tmp", ")", "{", "switch", "(", "degree", ")", "{", "case", "3", ":", "return", "cubic", "(", "out", ",", "i", ",", "u", ",", "points", ",", "continuous", ",", "tmp", ")", ";", "}", "throw", "new", "illegal", "argument", "exception", "(", ")", ";", "}" ]
[ "set", "whether", "to", "use", "the", "http", "1", "1", "cache", "-", "control", "header", "value", "\"", "no", "-", "store", "\"", "when", "preventing", "caching", "default", "is", "\"", "true", "\"" ]
[ "public", "final", "void", "set", "use", "cache", "control", "no", "store", "(", "boolean", "use", "cache", "control", "no", "store", ")", "{", "this", "use", "cache", "control", "no", "store", "=", "use", "cache", "control", "no", "store", ";", "}" ]
[ "sorts", "the", "elements", "of", "{", "@", "code", "array", "}", "in", "descending", "order", ",", "interpreting", "them", "as", "unsigned", "32", "-", "bit", "integers" ]
[ "public", "static", "void", "sort", "descending", "(", "int", "[", "]", "array", ")", "{", "check", "not", "null", "(", "array", ")", ";", "sort", "descending", "(", "array", ",", "0", ",", "array", "length", ")", ";", "}" ]
[ "returns", "the", "release", "timestamp", "in", "seconds" ]
[ "public", "long", "get", "timestamp", "(", ")", "{", "string", "timestamp", "=", "build", "data", "get", "(", "build", "timestamp", ")", ";", "if", "(", "timestamp", "=", "=", "null", "|", "|", "timestamp", "equals", "(", "\"", "0", "\"", ")", ")", "{", "return", "new", "date", "(", ")", "get", "time", "(", ")", ";", "}", "return", "long", "parse", "long", "(", "timestamp", ")", ";", "}" ]
[ "get", "exception", "classes", "to", "ignore" ]
[ "public", "static", "class", "<", "?", "extends", "throwable", ">", "[", "]", "get", "exceptions", "to", "ignore", "(", ")", "{", "return", "ignore", "classes", ";", "}" ]
[ "the", "same", "as", "{", "@", "link", "collections", "#", "binary", "search", "(", "list", ",", "object", ")", "}", "except", "that", "the", "list", "is", "a", "{", "@", "link", "read", "only", "list", "}" ]
[ "public", "static", "<", "k", ",", "e", "extends", "comparable", "<", "k", ">", ">", "int", "binary", "search", "(", "final", "read", "only", "list", "<", "e", ">", "list", ",", "final", "k", "key", ")", "{", "int", "lower", "=", "0", ";", "for", "(", "int", "upper", "=", "list", "size", "(", ")", "-", "1", ";", "lower", "<", "=", "upper", ";", ")", "{", "final", "int", "mid", "=", "(", "upper", "+", "lower", ")", ">", ">", ">", "1", ";", "final", "int", "d", "=", "list", "get", "(", "mid", ")", "compare", "to", "(", "key", ")", ";", "if", "(", "d", "=", "=", "0", ")", "{", "return", "mid", ";", "}", "else", "if", "(", "d", ">", "0", ")", "{", "upper", "=", "mid", "-", "1", ";", "}", "else", "{", "lower", "=", "mid", "+", "1", ";", "}", "}", "return", "-", "(", "lower", "+", "1", ")", ";", "}" ]
[ "returns", "the", "minimum", "version", "that", "can", "be", "used", "for", "compatible", "rest", "api" ]
[ "public", "version", "minimum", "rest", "compatibility", "version", "(", ")", "{", "return", "this", "previous", "major", "(", ")", ";", "}" ]
[ "verifies", "command", "line", "options", "are", "correctly", "materialized" ]
[ "public", "void", "test", "command", "line", "materialization", "(", ")", "throws", "exception", "{", "final", "string", "hostname", "=", "\"", "home", "-", "sweet", "-", "home", "\"", ";", "final", "int", "port", "=", "1234", ";", "final", "string", "[", "]", "args", "=", "{", "\"", "-", "m", "\"", ",", "hostname", "+", "'", ":", "'", "+", "port", "}", ";", "final", "abstract", "custom", "command", "line", "default", "c", "l", "i", "=", "new", "default", "c", "l", "i", "(", ")", ";", "final", "command", "line", "command", "line", "=", "default", "c", "l", "i", "parse", "command", "line", "options", "(", "args", ",", "false", ")", ";", "configuration", "configuration", "=", "default", "c", "l", "i", "to", "configuration", "(", "command", "line", ")", ";", "assert", "that", "(", "configuration", "get", "(", "rest", "options", "address", ")", ",", "is", "(", "hostname", ")", ")", ";", "assert", "that", "(", "configuration", "get", "(", "rest", "options", "port", ")", ",", "is", "(", "port", ")", ")", ";", "}" ]
[ "this", "field", "is", "reserved" ]
[ "public", "short", "get", "reserved", "(", ")", "{", "return", "reserved", ";", "}" ]
[ "the", "default", "implementation", "is", "empty", "can", "be", "overridden", "by", "subclasses", "as", "necessary" ]
[ "public", "void", "prepare", "test", "instance", "(", "test", "context", "test", "context", ")", "throws", "exception", "{", "/", "*", "no", "-", "op", "*", "/", "}" ]
[ "tests", "that", "a", "namenode", "doesn", "'", "t", "choose", "a", "datanode", "with", "full", "disks", "to", "store", "blocks" ]
[ "public", "void", "test", "storage", "with", "remaining", "capacity", "(", ")", "throws", "exception", "{", "final", "configuration", "conf", "=", "new", "hdfs", "configuration", "(", ")", ";", "final", "mini", "d", "f", "s", "cluster", "cluster", "=", "new", "mini", "d", "f", "s", "cluster", "builder", "(", "conf", ")", "build", "(", ")", ";", "file", "system", "fs", "=", "file", "system", "get", "(", "conf", ")", ";", "path", "file", "1", "=", "null", ";", "try", "{", "cluster", "wait", "active", "(", ")", ";", "final", "f", "s", "namesystem", "namesystem", "=", "cluster", "get", "namesystem", "(", ")", ";", "final", "string", "pool", "id", "=", "namesystem", "get", "block", "pool", "id", "(", ")", ";", "final", "datanode", "registration", "node", "reg", "=", "internal", "data", "node", "test", "utils", "get", "d", "n", "registration", "for", "b", "p", "(", "cluster", "get", "data", "nodes", "(", ")", "get", "(", "0", ")", ",", "pool", "id", ")", ";", "final", "datanode", "descriptor", "dd", "=", "name", "node", "adapter", "get", "datanode", "(", "namesystem", ",", "node", "reg", ")", ";", "/", "/", "by", "default", ",", "mini", "d", "f", "s", "cluster", "will", "create", "1", "datanode", "with", "2", "storages", "/", "/", "assigning", "6", "4k", "for", "remaining", "storage", "capacity", "and", "will", "/", "/", "create", "a", "file", "with", "1", "0", "0k", "for", "(", "datanode", "storage", "info", "storage", ":", "dd", "get", "storage", "infos", "(", ")", ")", "{", "storage", "set", "utilization", "for", "testing", "(", "65536", ",", "0", ",", "65536", ",", "0", ")", ";", "}", "/", "/", "sum", "of", "the", "remaining", "capacity", "of", "both", "the", "storages", "dd", "set", "remaining", "(", "131072", ")", ";", "file", "1", "=", "new", "path", "(", "\"", "test", "remaining", "storage", "dat", "\"", ")", ";", "try", "{", "d", "f", "s", "test", "util", "create", "file", "(", "fs", ",", "file", "1", ",", "102400", ",", "102400", ",", "102400", ",", "(", "short", ")", "1", ",", "0x", "1", "b", "a", "d", "5", "e", "e", "d", ")", ";", "}", "catch", "(", "remote", "exception", "re", ")", "{", "generic", "test", "utils", "assert", "exception", "contains", "(", "\"", "of", "the", "1", "min", "replication", "\"", ",", "re", ")", ";", "}", "}", "finally", "{", "/", "/", "clean", "up", "assert", "true", "(", "fs", "exists", "(", "file", "1", ")", ")", ";", "fs", "delete", "(", "file", "1", ",", "true", ")", ";", "assert", "true", "(", "!", "fs", "exists", "(", "file", "1", ")", ")", ";", "if", "(", "cluster", "!", "=", "null", ")", "{", "cluster", "shutdown", "(", ")", ";", "}", "}", "}" ]
[ "returns", "the", "number", "of", "values" ]
[ "public", "long", "count", "(", ")", "{", "return", "count", ";", "}" ]
[ "finds", "a", "class", "on", "the", "given", "classpath" ]
[ "private", "class", "find", "class", "in", "components", "(", "string", "name", ")", "throws", "class", "not", "found", "exception", "{", "/", "/", "we", "need", "to", "search", "the", "components", "of", "the", "path", "to", "see", "if", "/", "/", "we", "can", "find", "the", "class", "we", "want", "string", "class", "filename", "=", "get", "class", "filename", "(", "name", ")", ";", "for", "(", "file", "path", "component", ":", "path", "components", ")", "{", "try", "(", "final", "input", "stream", "stream", "=", "get", "resource", "stream", "(", "path", "component", ",", "class", "filename", ")", ")", "{", "if", "(", "stream", "!", "=", "null", ")", "{", "log", "(", "\"", "loaded", "from", "\"", "+", "path", "component", "+", "\"", "\"", "+", "class", "filename", ",", "project", "msg", "debug", ")", ";", "return", "get", "class", "from", "stream", "(", "stream", ",", "name", ",", "path", "component", ")", ";", "}", "}", "catch", "(", "security", "exception", "se", ")", "{", "throw", "se", ";", "}", "catch", "(", "i", "o", "exception", "ioe", ")", "{", "/", "/", "ioe", "print", "stack", "trace", "(", ")", ";", "log", "(", "\"", "exception", "reading", "component", "\"", "+", "path", "component", "+", "\"", "(", "reason", ":", "\"", "+", "ioe", "get", "message", "(", ")", "+", "\"", ")", "\"", ",", "project", "msg", "verbose", ")", ";", "}", "}", "throw", "new", "class", "not", "found", "exception", "(", "name", ")", ";", "}" ]
[ "returns", "the", "range", "attribute" ]
[ "public", "range", "attribute", "get", "range", "attribute", "(", ")", "{", "return", "range", "attribute", ";", "}" ]
[ "{", "@", "link", "#", "execute", "async", "(", "call", ",", "type", ",", "api", "callback", ")", "}" ]
[ "public", "<", "t", ">", "void", "execute", "async", "(", "call", "call", ",", "api", "callback", "<", "t", ">", "callback", ")", "{", "execute", "async", "(", "call", ",", "null", ",", "callback", ")", ";", "}" ]
[ "sets", "the", "exif", "orientation" ]
[ "public", "void", "set", "exif", "orientation", "(", "int", "exif", "orientation", ")", "{", "this", "m", "exif", "orientation", "=", "exif", "orientation", ";", "}" ]
[ "free", "the", "resources", "associated", "with", "this", "peer", "server", "this", "normally", "includes", "sockets", ",", "etc" ]
[ "public", "void", "close", "(", ")", "throws", "i", "o", "exception", ";" ]
[ "a", "test", "that", "checks", "for", "a", "npe", "that", "would", "occur", "if", "when", "processing", "{", "@", "link", "last", "http", "content", "#", "empty", "last", "content", "}", "when", "a", "certain", "initialization", "order", "of", "{", "@", "link", "empty", "http", "headers", "}", "would", "occur" ]
[ "public", "void", "test", "for", "chunked", "request", "npe", "(", ")", "throws", "exception", "{", "embedded", "channel", "channel", "=", "new", "embedded", "channel", "(", "new", "http", "request", "encoder", "(", ")", ")", ";", "assert", "true", "(", "channel", "write", "outbound", "(", "new", "custom", "http", "request", "(", ")", ")", ")", ";", "assert", "true", "(", "channel", "write", "outbound", "(", "new", "default", "http", "content", "(", "unpooled", "copied", "buffer", "(", "\"", "test", "\"", ",", "charset", "util", "us", "ascii", ")", ")", ")", ")", ";", "assert", "true", "(", "channel", "write", "outbound", "(", "last", "http", "content", "empty", "last", "content", ")", ")", ";", "assert", "true", "(", "channel", "finish", "and", "release", "all", "(", ")", ")", ";", "}" ]
[ "called", "when", "creating", "a", "new", "job" ]
[ "public", "void", "check", "name", "(", "string", "name", ")", "throws", "failure", "{", "/", "/", "no", "op", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "int", "code", "size", "(", ")", "{", "return", "packed", "?", "(", "int", ")", "packed", "code", "size", "(", "cases", ")", ":", "(", "int", ")", "sparse", "code", "size", "(", "cases", ")", ";", "}" ]
[ "merges", "all", "links", "in", "the", "lattice", "among", "two", "escape", "sets", "on", "return", ",", "the", "new", "node", "will", "have", "its", "old", "links", "as", "well", "as", "all", "links", "from", "the", "old", "node", "the", "old", "node", "has", "all", "its", "links", "removed" ]
[ "private", "void", "replace", "node", "(", "escape", "set", "new", "node", ",", "escape", "set", "old", "node", ")", "{", "for", "(", "escape", "set", "e", ":", "old", "node", "parent", "sets", ")", "{", "e", "child", "sets", "remove", "(", "old", "node", ")", ";", "e", "child", "sets", "add", "(", "new", "node", ")", ";", "new", "node", "parent", "sets", "add", "(", "e", ")", ";", "}", "for", "(", "escape", "set", "e", ":", "old", "node", "child", "sets", ")", "{", "e", "parent", "sets", "remove", "(", "old", "node", ")", ";", "e", "parent", "sets", "add", "(", "new", "node", ")", ";", "new", "node", "child", "sets", "add", "(", "e", ")", ";", "}", "}" ]
[ "called", "when", "a", "{", "@", "link", "gauge", "}", "is", "added", "to", "the", "registry" ]
[ "void", "on", "gauge", "added", "(", "string", "name", ",", "gauge", "<", "?", ">", "gauge", ")", ";" ]
[ "sets", "the", "<", "code", ">", "color", "<", "code", ">", "property" ]
[ "public", "void", "set", "color", "(", "string", "color", ")", "{", "this", "color", "=", "color", ";", "}" ]
[ "trying", "to", "rename", "a", "file", "onto", "itself", "should", "succeed", "(", "it", "'", "s", "a", "no", "-", "op", ")" ]
[ "public", "void", "test", "rename", "file", "to", "self", "(", ")", "throws", "throwable", "{", "assume", "true", "(", "rename", "supported", "(", ")", ")", ";", "path", "filepath", "=", "path", "(", "\"", "test", "rename", "file", "to", "self", "\"", ")", ";", "create", "file", "(", "filepath", ")", ";", "/", "/", "hdfs", "expects", "rename", "src", ",", "src", "-", ">", "true", "rename", "(", "filepath", ",", "filepath", ",", "true", ",", "true", ",", "true", ")", ";", "/", "/", "verify", "the", "file", "is", "still", "there", "assert", "is", "file", "(", "filepath", ")", ";", "}" ]
[ "called", "when", "the", "specified", "controller", "has", "set", "a", "rating", "for", "the", "specified", "media", "id" ]
[ "int", "on", "set", "rating", "(", "media", "session", "session", ",", "controller", "info", "controller", ",", "string", "media", "id", ",", "rating", "rating", ")", ";" ]
[ "add", "a", "value", "to", "the", "aggregator" ]
[ "public", "void", "add", "next", "value", "(", "long", "new", "val", ")", "{", "if", "(", "this", "max", "val", "<", "new", "val", ")", "{", "this", "max", "val", "=", "new", "val", ";", "}", ";", "}" ]
[ "get", "bool", "item" ]
[ "public", "boolean", "get", "bool", "item", "(", ")", "{", "return", "bool", "item", ";", "}" ]
[ "get", "the", "first", "header", "value", ",", "if", "any", ",", "for", "the", "header", "with", "the", "given", "name", "returns", "{", "@", "code", "null", "}", "if", "no", "header", "values", "are", "found" ]
[ "default", "string", "first", "header", "(", "string", "header", "name", ")", "{", "list", "<", "string", ">", "list", "=", "header", "(", "header", "name", ")", ";", "return", "list", "is", "empty", "(", ")", "?", "null", ":", "list", "get", "(", "0", ")", ";", "}" ]
[ "get", "the", "remoting", "description", "of", "tcc", "bean" ]
[ "public", "static", "remoting", "desc", "get", "remoting", "desc", "(", "string", "bean", "name", ")", "{", "return", "default", "remoting", "parser", "get", "(", ")", "get", "remoting", "bean", "desc", "(", "bean", "name", ")", ";", "}" ]
[ "returns", "an", "array", "of", "the", "dynamics", "defined", "this", "dynamic", "header" ]
[ "public", "elf", "dynamic", "[", "]", "get", "dynamics", "(", ")", "{", "elf", "dynamic", "[", "]", "array", "=", "new", "elf", "dynamic", "[", "dynamics", "size", "(", ")", "]", ";", "dynamics", "to", "array", "(", "array", ")", ";", "return", "array", ";", "}" ]
[ "encrypt", "using", "the", "given", "cipher", "associated", "with", "the", "service", ",", "and", "encode", "the", "data", "in", "base", "64" ]
[ "public", "string", "encode", "(", "final", "string", "data", ",", "final", "optional", "<", "registered", "service", ">", "service", ")", "{", "try", "{", "if", "(", "service", "is", "present", "(", ")", ")", "{", "val", "registered", "service", "=", "service", "get", "(", ")", ";", "val", "result", "=", "encode", "internal", "(", "data", ",", "registered", "service", ")", ";", "if", "(", "result", "!", "=", "null", ")", "{", "return", "encoding", "utils", "encode", "base", "6", "4", "(", "result", ")", ";", "}", "}", "}", "catch", "(", "final", "exception", "e", ")", "{", "logging", "utils", "warn", "(", "logger", ",", "e", ")", ";", "}", "return", "null", ";", "}" ]
[ "filters", "these", "properties", "by", "what", "can", "be", "preserved", "by", "the", "given", "semantic", "properties", "when", "propagated", "down", "to", "the", "given", "input" ]
[ "public", "requested", "local", "properties", "filter", "by", "semantic", "properties", "(", "semantic", "properties", "props", ",", "int", "input", ")", "{", "/", "/", "no", "semantic", "properties", ",", "all", "local", "properties", "are", "filtered", "if", "(", "props", "=", "=", "null", ")", "{", "throw", "new", "null", "pointer", "exception", "(", "\"", "semantic", "properties", "may", "not", "be", "null", "\"", ")", ";", "}", "if", "(", "this", "ordering", "!", "=", "null", ")", "{", "ordering", "new", "ordering", "=", "new", "ordering", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "this", "ordering", "get", "involved", "indexes", "(", ")", "size", "(", ")", ";", "i", "+", "+", ")", "{", "int", "target", "field", "=", "this", "ordering", "get", "involved", "indexes", "(", ")", "get", "(", "i", ")", ";", "int", "source", "field", "=", "props", "get", "forwarding", "source", "field", "(", "input", ",", "target", "field", ")", ";", "if", "(", "source", "field", ">", "=", "0", ")", "{", "new", "ordering", "append", "ordering", "(", "source", "field", ",", "this", "ordering", "get", "type", "(", "i", ")", ",", "this", "ordering", "get", "order", "(", "i", ")", ")", ";", "}", "else", "{", "return", "null", ";", "}", "}", "return", "new", "requested", "local", "properties", "(", "new", "ordering", ")", ";", "}", "else", "if", "(", "this", "grouped", "fields", "!", "=", "null", ")", "{", "field", "set", "new", "grouping", "=", "new", "field", "set", "(", ")", ";", "/", "/", "check", ",", "whether", "the", "local", "key", "grouping", "is", "preserved", "for", "(", "integer", "target", "field", ":", "this", "grouped", "fields", ")", "{", "int", "source", "field", "=", "props", "get", "forwarding", "source", "field", "(", "input", ",", "target", "field", ")", ";", "if", "(", "source", "field", ">", "=", "0", ")", "{", "new", "grouping", "=", "new", "grouping", "add", "field", "(", "source", "field", ")", ";", "}", "else", "{", "return", "null", ";", "}", "}", "return", "new", "requested", "local", "properties", "(", "new", "grouping", ")", ";", "}", "else", "{", "return", "null", ";", "}", "}" ]
[ "read", "from", "input", "stream", "and", "fill", "the", "given", "buffer", "from", "the", "given", "offset", "up", "to", "length", "len" ]
[ "public", "static", "final", "boolean", "read", "from", "stream", "(", "input", "stream", "in", ",", "byte", "[", "]", "buf", ",", "int", "offset", ",", "int", "len", ")", "throws", "i", "o", "exception", "{", "int", "total", "bytes", "read", "=", "0", ";", "while", "(", "total", "bytes", "read", "<", "len", ")", "{", "int", "bytes", "read", "=", "in", "read", "(", "buf", ",", "offset", "+", "total", "bytes", "read", ",", "len", "-", "total", "bytes", "read", ")", ";", "if", "(", "bytes", "read", "<", "0", ")", "{", "return", "false", ";", "}", "total", "bytes", "read", "+", "=", "bytes", "read", ";", "}", "return", "true", ";", "}" ]
[ "post", "pet", ":", "add", "a", "new", "pet", "to", "the", "store" ]
[ "default", "response", "entity", "<", "void", ">", "add", "pet", "(", "@", "api", "param", "(", "value", "=", "\"", "pet", "object", "that", "needs", "to", "be", "added", "to", "the", "store", "\"", ",", "required", "=", "true", ")", "@", "valid", "@", "request", "body", "pet", "body", ")", "{", "return", "new", "response", "entity", "<", ">", "(", "http", "status", "not", "implemented", ")", ";", "}" ]
[ "auto", "upgrade", "service", "detection" ]
[ "private", "static", "void", "start", "degrade", "check", "(", ")", "{", "executor", "schedule", "at", "fixed", "rate", "(", "(", ")", "-", ">", "{", "if", "(", "degrade", "check", ")", "{", "try", "{", "string", "xid", "=", "transaction", "manager", "holder", "get", "(", ")", "begin", "(", "null", ",", "null", ",", "\"", "degrade", "check", "\"", ",", "60000", ")", ";", "transaction", "manager", "holder", "get", "(", ")", "commit", "(", "xid", ")", ";", "event", "bus", "post", "(", "new", "degrade", "check", "event", "(", "true", ")", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "event", "bus", "post", "(", "new", "degrade", "check", "event", "(", "false", ")", ")", ";", "}", "}", "}", ",", "degrade", "check", "period", ",", "degrade", "check", "period", ",", "time", "unit", "milliseconds", ")", ";", "}" ]
[ "test", "the", "property", "'", "name", "wrapped", "array", "'" ]
[ "public", "void", "name", "wrapped", "array", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "name", "wrapped", "array", "}" ]
[ "tests", "that", "endless", "loops", "(", "impossible", "without", "manual", "editing", "or", "intentional", "creation", "of", "bad", "data", ")", "does", "not", "cause", "endless", "loop", "when", "processing" ]
[ "public", "void", "test", "hostile", "ptr", "loop", "(", ")", "throws", "cancelled", "exception", ",", "i", "o", "exception", ",", "d", "w", "a", "r", "f", "exception", "{", "/", "/", "hack", "to", "make", "a", "forward", "reference", "to", "a", "die", "that", "hasn", "'", "t", "been", "created", "yet", "/", "/", "this", "creates", "a", "hostile", "loop", "in", "the", "data", "type", "references", "debug", "info", "entry", "const", "d", "i", "e", "=", "new", "d", "i", "e", "creator", "(", "d", "w", "a", "r", "f", "tag", "dw", "tag", "const", "type", ")", "add", "ref", "(", "dw", "at", "type", ",", "get", "forward", "offset", "(", "cu", ",", "1", ")", ")", "create", "(", "cu", ")", ";", "debug", "info", "entry", "ptr", "d", "i", "e", "=", "new", "d", "i", "e", "creator", "(", "d", "w", "a", "r", "f", "tag", "dw", "tag", "pointer", "type", ")", "add", "ref", "(", "dw", "at", "type", ",", "const", "d", "i", "e", ")", "create", "(", "cu", ")", ";", "import", "all", "data", "types", "(", ")", ";", "data", "type", "const", "d", "t", "=", "dwarf", "d", "t", "m", "get", "data", "type", "(", "const", "d", "i", "e", "get", "offset", "(", ")", ",", "null", ")", ";", "data", "type", "ptr", "d", "t", "=", "dwarf", "d", "t", "m", "get", "data", "type", "(", "ptr", "d", "i", "e", "get", "offset", "(", ")", ",", "null", ")", ";", "assert", "not", "null", "(", "const", "d", "t", ")", ";", "assert", "equals", "(", "dwarf", "d", "t", "m", "get", "void", "type", "(", ")", ",", "(", "(", "pointer", ")", "ptr", "d", "t", ")", "get", "data", "type", "(", ")", ")", ";", "}" ]
[ "rotates", "this", "sprite", "90", "degrees", "in", "-", "place", "by", "rotating", "the", "texture", "coordinates", "this", "rotation", "is", "unaffected", "by", "{", "@", "link", "#", "set", "rotation", "(", "float", ")", "}", "and", "{", "@", "link", "#", "rotate", "(", "float", ")", "}" ]
[ "public", "void", "rotate", "9", "0", "(", "boolean", "clockwise", ")", "{", "float", "[", "]", "vertices", "=", "this", "vertices", ";", "if", "(", "clockwise", ")", "{", "float", "temp", "=", "vertices", "[", "v1", "]", ";", "vertices", "[", "v1", "]", "=", "vertices", "[", "v4", "]", ";", "vertices", "[", "v4", "]", "=", "vertices", "[", "v3", "]", ";", "vertices", "[", "v3", "]", "=", "vertices", "[", "v2", "]", ";", "vertices", "[", "v2", "]", "=", "temp", ";", "temp", "=", "vertices", "[", "u1", "]", ";", "vertices", "[", "u1", "]", "=", "vertices", "[", "u4", "]", ";", "vertices", "[", "u4", "]", "=", "vertices", "[", "u3", "]", ";", "vertices", "[", "u3", "]", "=", "vertices", "[", "u2", "]", ";", "vertices", "[", "u2", "]", "=", "temp", ";", "}", "else", "{", "float", "temp", "=", "vertices", "[", "v1", "]", ";", "vertices", "[", "v1", "]", "=", "vertices", "[", "v2", "]", ";", "vertices", "[", "v2", "]", "=", "vertices", "[", "v3", "]", ";", "vertices", "[", "v3", "]", "=", "vertices", "[", "v4", "]", ";", "vertices", "[", "v4", "]", "=", "temp", ";", "temp", "=", "vertices", "[", "u1", "]", ";", "vertices", "[", "u1", "]", "=", "vertices", "[", "u2", "]", ";", "vertices", "[", "u2", "]", "=", "vertices", "[", "u3", "]", ";", "vertices", "[", "u3", "]", "=", "vertices", "[", "u4", "]", ";", "vertices", "[", "u4", "]", "=", "temp", ";", "}", "}" ]
[ "sets", "whether", "an", "animation", "is", "used", "to", "show", "and", "hide", "the", "playback", "controls" ]
[ "public", "void", "set", "animation", "enabled", "(", "boolean", "animation", "enabled", ")", "{", "control", "view", "layout", "manager", "set", "animation", "enabled", "(", "animation", "enabled", ")", ";", "}" ]
[ "serializes", "an", "object", "and", "returns", "the", "base", "6", "4", "-", "encoded", "version", "of", "that", "serialized", "object", "as", "of", "v", "2", "3", ",", "if", "the", "object", "cannot", "be", "serialized", "or", "there", "is", "another", "error", ",", "the", "method", "will", "throw", "an", "java", "io", "i", "o", "exception", "<", "b", ">", "this", "is", "new", "to", "v", "2", "3", "!", "<", "b", ">", "in", "earlier", "versions", ",", "it", "just", "returned", "a", "null", "value", ",", "but", "in", "retrospect", "that", "'", "s", "a", "pretty", "poor", "way", "to", "handle", "it", "the", "object", "is", "not", "g", "zip", "-", "compressed", "before", "being", "encoded", "example", "options", ":", "gzip", ":", "gzip", "-", "compresses", "object", "before", "encoding", "it", "do", "break", "lines", ":", "break", "lines", "at", "76", "characters", "example", ":", "<", "code", ">", "encode", "object", "(", "my", "obj", ",", "base", "6", "4", "gzip", ")", "<", "code", ">", "or", "example", ":", "<", "code", ">", "encode", "object", "(", "my", "obj", ",", "base", "6", "4", "gzip", "|", "base", "6", "4", "do", "break", "lines", ")", "<", "code", ">" ]
[ "public", "static", "string", "encode", "object", "(", "java", "io", "serializable", "serializable", "object", ",", "int", "options", ")", "throws", "java", "io", "i", "o", "exception", "{", "if", "(", "serializable", "object", "=", "=", "null", ")", "{", "throw", "new", "null", "pointer", "exception", "(", "\"", "cannot", "serialize", "a", "null", "object", "\"", ")", ";", "}", "/", "/", "end", "if", ":", "null", "/", "/", "streams", "java", "io", "byte", "array", "output", "stream", "baos", "=", "null", ";", "java", "io", "output", "stream", "b", "6", "4os", "=", "null", ";", "java", "util", "zip", "g", "z", "i", "p", "output", "stream", "gzos", "=", "null", ";", "java", "io", "object", "output", "stream", "oos", "=", "null", ";", "try", "{", "/", "/", "object", "output", "stream", "-", ">", "(", "gzip", ")", "-", ">", "base", "6", "4", "-", ">", "byte", "array", "output", "stream", "baos", "=", "new", "java", "io", "byte", "array", "output", "stream", "(", ")", ";", "b", "6", "4os", "=", "new", "base", "6", "4", "output", "stream", "(", "baos", ",", "encode", "|", "options", ")", ";", "if", "(", "(", "options", "&", "gzip", ")", "!", "=", "0", ")", "{", "/", "/", "gzip", "gzos", "=", "new", "java", "util", "zip", "g", "z", "i", "p", "output", "stream", "(", "b", "6", "4os", ")", ";", "oos", "=", "new", "java", "io", "object", "output", "stream", "(", "gzos", ")", ";", "}", "else", "{", "/", "/", "not", "gzipped", "oos", "=", "new", "java", "io", "object", "output", "stream", "(", "b", "6", "4os", ")", ";", "}", "oos", "write", "object", "(", "serializable", "object", ")", ";", "}", "/", "/", "end", "try", "catch", "(", "java", "io", "i", "o", "exception", "e", ")", "{", "/", "/", "catch", "it", "and", "then", "throw", "it", "immediately", "so", "that", "/", "/", "the", "finally", "{", "}", "block", "is", "called", "for", "cleanup", "throw", "e", ";", "}", "/", "/", "end", "catch", "finally", "{", "try", "{", "oos", "close", "(", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "}", "try", "{", "gzos", "close", "(", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "}", "try", "{", "b", "6", "4os", "close", "(", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "}", "try", "{", "baos", "close", "(", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "}", "}", "/", "/", "end", "finally", "/", "/", "return", "value", "according", "to", "relevant", "encoding", "try", "{", "return", "new", "string", "(", "baos", "to", "byte", "array", "(", ")", ",", "preferred", "encoding", ")", ";", "}", "/", "/", "end", "try", "catch", "(", "java", "io", "unsupported", "encoding", "exception", "uue", ")", "{", "/", "/", "fall", "back", "to", "some", "java", "default", "return", "new", "string", "(", "baos", "to", "byte", "array", "(", ")", ")", ";", "}", "/", "/", "end", "catch", "}" ]
[ "set", "the", "body", "of", "the", "request", "if", "not", "set", "or", "set", "to", "{", "@", "code", "null", "}", "then", "no", "body", "is", "sent", "with", "the", "request" ]
[ "public", "void", "set", "entity", "(", "http", "entity", "entity", ")", "{", "this", "entity", "=", "entity", ";", "}" ]
[ "configure", "the", "codecs", "for", "the", "{", "@", "code", "web", "client", "}", "in", "the", "{", "@", "link", "#", "exchange", "strategies", "(", "exchange", "strategies", ")", "underlying", "}", "{", "@", "code", "exchange", "strategies", "}" ]
[ "builder", "codecs", "(", "consumer", "<", "client", "codec", "configurer", ">", "configurer", ")", ";" ]
[ "only", "report", "metrics", "which", "match", "the", "given", "filter" ]
[ "public", "builder", "filter", "(", "metric", "filter", "filter", ")", "{", "this", "filter", "=", "filter", ";", "return", "this", ";", "}" ]
[ "this", "is", "populated", "when", "the", "previous", "incremental", "mesh", "config", "responses", "failed", "to", "update", "configuration", "the", "message", "field", "in", "error", "details", "provides", "the", "client", "internal", "exception", "related", "to", "the", "failure", "<", "code", ">", "google", "rpc", "status", "error", "detail", "=", "5", ";", "<", "code", ">" ]
[ "public", "builder", "set", "error", "detail", "(", "com", "google", "rpc", "status", "builder", "builder", "for", "value", ")", "{", "if", "(", "error", "detail", "builder", "=", "=", "null", ")", "{", "error", "detail", "=", "builder", "for", "value", "build", "(", ")", ";", "on", "changed", "(", ")", ";", "}", "else", "{", "error", "detail", "builder", "set", "message", "(", "builder", "for", "value", "build", "(", ")", ")", ";", "}", "return", "this", ";", "}" ]
[ "overrides", "the", "{", "@", "link", "com", "bumptech", "glide", "request", "target", "target", "}", "'", "s", "width", "and", "height", "with", "the", "given", "size" ]
[ "public", "t", "override", "(", "int", "size", ")", "{", "return", "override", "(", "size", ",", "size", ")", ";", "}" ]
[ "removes", "and", "returns", "a", "value", "that", "has", "no", "dependencies", "from", "the", "graph", "if", "the", "graph", "is", "empty", "or", "all", "the", "nodes", "without", "dependencies", "are", "currently", "visited", ",", "then", "null", "will", "be", "returned", "note", ":", "if", "the", "get", "unvisited", "independent", "values", "(", ")", "method", "has", "been", "called", "(", ")", ",", "this", "method", "may", "return", "null", "until", "all", "those", "\"", "visited", "\"", "nodes", "are", "removed", "from", "the", "graph" ]
[ "public", "synchronized", "t", "pop", "(", ")", "{", "check", "cycle", "state", "(", ")", ";", "if", "(", "unvisited", "independent", "set", "is", "empty", "(", ")", ")", "{", "return", "null", ";", "}", "t", "value", "=", "unvisited", "independent", "set", "iterator", "(", ")", "next", "(", ")", ";", "unvisited", "independent", "set", "remove", "(", "value", ")", ";", "remove", "(", "value", ")", ";", "return", "value", ";", "}" ]
[ "returns", "true", "if", "the", "given", "signature", "is", "equivalent", "to", "this", "signature", "the", "precise", "meaning", "of", "\"", "equivalent", "\"", "is", "dependent", "upon", "returnparameter", "data", "types" ]
[ "public", "boolean", "is", "equivalent", "signature", "(", "function", "signature", "signature", ")", ";" ]
[ "gets", "the", "size", "(", "in", "bytes", ")", "that", "a", "individual", "chunk", "of", "state", "may", "have", "at", "most" ]
[ "public", "int", "get", "max", "state", "size", "(", ")", "{", "return", "max", "state", "size", ";", "}" ]
[ "returns", "a", "name", "representing", "the", "type", "of", "this", "mapper" ]
[ "public", "abstract", "string", "type", "name", "(", ")", ";" ]
[ "create", "a", "server", "tls", "handler", "for", "http2", "capable", "of", "using", "alpnnpn" ]
[ "public", "static", "protocol", "negotiator", "server", "tls", "(", "final", "ssl", "context", "ssl", "context", ",", "final", "object", "pool", "<", "?", "extends", "executor", ">", "executor", "pool", ")", "{", "preconditions", "check", "not", "null", "(", "ssl", "context", ",", "\"", "ssl", "context", "\"", ")", ";", "final", "executor", "executor", ";", "if", "(", "executor", "pool", "!", "=", "null", ")", "{", "/", "/", "the", "handlers", "here", "can", "out", "-", "live", "the", "{", "@", "link", "protocol", "negotiator", "}", "/", "/", "to", "keep", "their", "own", "reference", "to", "executor", "from", "executor", "pool", ",", "we", "use", "an", "extra", "(", "unused", ")", "/", "/", "reference", "here", "forces", "the", "executor", "to", "stay", "alive", ",", "which", "prevents", "it", "from", "being", "re", "-", "created", "/", "/", "for", "every", "connection", "executor", "=", "executor", "pool", "get", "object", "(", ")", ";", "}", "else", "{", "executor", "=", "null", ";", "}", "return", "new", "protocol", "negotiator", "(", ")", "{", "@", "override", "public", "channel", "handler", "new", "handler", "(", "grpc", "http", "2", "connection", "handler", "handler", ")", "{", "channel", "handler", "gnh", "=", "new", "grpc", "negotiation", "handler", "(", "handler", ")", ";", "channel", "handler", "sth", "=", "new", "server", "tls", "handler", "(", "gnh", ",", "ssl", "context", ",", "executor", "pool", ")", ";", "return", "new", "wait", "until", "active", "handler", "(", "sth", ")", ";", "}", "@", "override", "public", "void", "close", "(", ")", "{", "if", "(", "executor", "pool", "!", "=", "null", "&", "&", "executor", "!", "=", "null", ")", "{", "executor", "pool", "return", "object", "(", "executor", ")", ";", "}", "}", "@", "override", "public", "ascii", "string", "scheme", "(", ")", "{", "return", "utils", "https", ";", "}", "}", ";", "}" ]
[ "replaces", "the", "specified", "{", "@", "link", "channel", "handler", "}", "with", "a", "new", "handler", "in", "this", "pipeline" ]
[ "channel", "pipeline", "replace", "(", "channel", "handler", "old", "handler", ",", "string", "new", "name", ",", "channel", "handler", "new", "handler", ")", ";" ]