Datasets:

Anonymous2023

/

KGSum

like 0

[ "compute", "the", "variable", "storage", "for", "a", "given", "function", "and", "set", "of", "returnparameter", "datatypes", "defined", "by", "an", "array", "of", "data", "types" ]

[ "public", "variable", "storage", "[", "]", "get", "storage", "locations", "(", "program", "program", ",", "data", "type", "[", "]", "data", "types", ",", "boolean", "add", "auto", "params", ")", "{", "boolean", "inject", "auto", "this", "param", "=", "false", ";", "if", "(", "add", "auto", "params", "&", "&", "has", "this", ")", "{", "/", "/", "explicit", "support", "for", "auto", "'", "this", "'", "parameter", "/", "/", "must", "inject", "pointer", "arg", "to", "obtain", "storage", "assignment", "inject", "auto", "this", "param", "=", "true", ";", "data", "type", "[", "]", "ammended", "types", "=", "new", "data", "type", "[", "data", "types", "length", "+", "1", "]", ";", "ammended", "types", "[", "0", "]", "=", "data", "types", "[", "0", "]", ";", "ammended", "types", "[", "1", "]", "=", "new", "pointer", "data", "type", "(", "program", "get", "data", "type", "manager", "(", ")", ")", ";", "if", "(", "data", "types", "length", ">", "1", ")", "{", "system", "arraycopy", "(", "data", "types", ",", "1", ",", "ammended", "types", ",", "2", ",", "data", "types", "length", "-", "1", ")", ";", "}", "data", "types", "=", "ammended", "types", ";", "}", "array", "list", "<", "variable", "storage", ">", "res", "=", "new", "array", "list", "<", "variable", "storage", ">", "(", ")", ";", "output", "params", "assign", "map", "(", "program", ",", "data", "types", ",", "false", ",", "res", ",", "add", "auto", "params", ")", ";", "input", "params", "assign", "map", "(", "program", ",", "data", "types", ",", "true", ",", "res", ",", "add", "auto", "params", ")", ";", "variable", "storage", "[", "]", "finalres", "=", "new", "variable", "storage", "[", "res", "size", "(", ")", "]", ";", "res", "to", "array", "(", "finalres", ")", ";", "if", "(", "inject", "auto", "this", "param", ")", "{", "varnode", "[", "]", "this", "varnodes", "=", "finalres", "[", "1", "]", "get", "varnodes", "(", ")", ";", "int", "this", "index", "=", "1", ";", "try", "{", "if", "(", "finalres", "[", "1", "]", "is", "auto", "storage", "(", ")", ")", "{", "if", "(", "input", "params", "is", "this", "before", "ret", "pointer", "(", ")", ")", "{", "/", "/", "pointer", "has", "been", "bumped", "by", "auto", "-", "return", "-", "storage", "/", "/", "must", "swap", "storage", "and", "position", "for", "slots", "1", "and", "2", "finalres", "[", "2", "]", "=", "new", "dynamic", "variable", "storage", "(", "program", ",", "finalres", "[", "1", "]", "get", "auto", "parameter", "type", "(", ")", ",", "finalres", "[", "2", "]", "get", "varnodes", "(", ")", ")", ";", "}", "else", "{", "this", "index", "=", "2", ";", "this", "varnodes", "=", "finalres", "[", "2", "]", "get", "varnodes", "(", ")", ";", "}", "}", "if", "(", "this", "varnodes", "length", "!", "=", "0", ")", "{", "finalres", "[", "this", "index", "]", "=", "new", "dynamic", "variable", "storage", "(", "program", ",", "auto", "parameter", "type", "this", ",", "this", "varnodes", ")", ";", "}", "else", "{", "finalres", "[", "this", "index", "]", "=", "dynamic", "variable", "storage", "get", "unassigned", "dynamic", "storage", "(", "auto", "parameter", "type", "this", ")", ";", "}", "}", "catch", "(", "invalid", "input", "exception", "e", ")", "{", "finalres", "[", "this", "index", "]", "=", "dynamic", "variable", "storage", "get", "unassigned", "dynamic", "storage", "(", "auto", "parameter", "type", "this", ")", ";", "}", "}", "return", "finalres", ";", "}" ]

[ "adds", "val", "to", "the", "small", "set", "returns", "some", "element", "of", "the", "small", "set" ]

[ "private", "synchronized", "t", "put", "and", "get", "(", "t", "elt", ")", "{", "preconditions", "check", "not", "null", "(", "elt", ")", ";", "if", "(", "is", "dead", "(", ")", ")", "{", "return", "null", ";", "}", "if", "(", "elt", "equals", "(", "first", ")", ")", "{", "return", "first", ";", "}", "if", "(", "first", "=", "=", "null", ")", "{", "preconditions", "check", "state", "(", "rest", "=", "=", "null", ",", "elt", ")", ";", "first", "=", "elt", ";", "return", "first", ";", "}", "if", "(", "rest", "=", "=", "null", ")", "{", "rest", "=", "sets", "new", "hash", "set", "(", ")", ";", "}", "rest", "add", "(", "elt", ")", ";", "return", "first", ";", "}" ]

[ "creates", "a", "new", "int", "property", "map", "with", "the", "given", "name" ]

[ "public", "int", "property", "map", "create", "int", "property", "map", "(", "string", "property", "name", ")", "throws", "duplicate", "name", "exception", "{", "lock", "acquire", "(", ")", ";", "try", "{", "if", "(", "property", "map", "cache", "contains", "key", "(", "property", "name", ")", ")", "{", "throw", "new", "duplicate", "name", "exception", "(", ")", ";", "}", "int", "property", "map", "pm", "=", "null", ";", "try", "{", "pm", "=", "new", "int", "property", "map", "d", "b", "(", "db", "handle", ",", "d", "b", "constants", "create", ",", "program", ",", "change", "mgr", ",", "addr", "map", ",", "property", "name", ",", "task", "monitor", "adapter", "dummy", "monitor", ")", ";", "properties", "d", "b", "adapter", "put", "record", "(", "property", "name", ",", "int", "property", "type", ",", "null", ")", ";", "property", "map", "cache", "put", "(", "property", "name", ",", "pm", ")", ";", "}", "catch", "(", "version", "exception", "e", ")", "{", "throw", "new", "assert", "exception", "(", ")", ";", "}", "catch", "(", "cancelled", "exception", "e", ")", "{", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "program", "db", "error", "(", "e", ")", ";", "}", "return", "pm", ";", "}", "finally", "{", "lock", "release", "(", ")", ";", "}", "}" ]

[ "see", "{", "@", "link", "collection", "iterator", "tester", "}" ]

[ "static", "int", "collection", "iterator", "tester", "num", "iterations", "(", ")", "{", "return", "5", ";", "}" ]

[ "sets", "the", "backing", "{", "@", "link", "thread", "factory", "}", "for", "new", "threads", "created", "with", "this", "thread", "factory", "threads", "will", "be", "created", "by", "invoking", "#", "new", "thread", "(", "runnable", ")", "on", "this", "backing", "{", "@", "link", "thread", "factory", "}" ]

[ "public", "thread", "factory", "builder", "set", "thread", "factory", "(", "thread", "factory", "backing", "thread", "factory", ")", "{", "this", "backing", "thread", "factory", "=", "check", "not", "null", "(", "backing", "thread", "factory", ")", ";", "return", "this", ";", "}" ]

[ "fake", "endpoint", "for", "testing", "various", "parameters", "가짜", "엔드", "포인트", "fake", "endpoint", "for", "testing", "various", "parameters", "가짜", "엔드", "포인트" ]

[ "public", "void", "test", "endpoint", "parameters", "(", "big", "decimal", "number", ",", "double", "double", ",", "string", "pattern", "without", "delimiter", ",", "byte", "[", "]", "byte", ",", "integer", "integer", ",", "integer", "int", "3", "2", ",", "long", "int", "6", "4", ",", "float", "float", ",", "string", "string", ",", "file", "binary", ",", "local", "date", "date", ",", "offset", "date", "time", "date", "time", ",", "string", "password", ",", "string", "param", "callback", ")", "throws", "api", "exception", "{", "object", "local", "var", "post", "body", "=", "null", ";", "/", "/", "verify", "the", "required", "parameter", "'", "number", "'", "is", "set", "if", "(", "number", "=", "=", "null", ")", "{", "throw", "new", "api", "exception", "(", "400", ",", "\"", "missing", "the", "required", "parameter", "'", "number", "'", "when", "calling", "test", "endpoint", "parameters", "\"", ")", ";", "}", "/", "/", "verify", "the", "required", "parameter", "'", "double", "'", "is", "set", "if", "(", "double", "=", "=", "null", ")", "{", "throw", "new", "api", "exception", "(", "400", ",", "\"", "missing", "the", "required", "parameter", "'", "double", "'", "when", "calling", "test", "endpoint", "parameters", "\"", ")", ";", "}", "/", "/", "verify", "the", "required", "parameter", "'", "pattern", "without", "delimiter", "'", "is", "set", "if", "(", "pattern", "without", "delimiter", "=", "=", "null", ")", "{", "throw", "new", "api", "exception", "(", "400", ",", "\"", "missing", "the", "required", "parameter", "'", "pattern", "without", "delimiter", "'", "when", "calling", "test", "endpoint", "parameters", "\"", ")", ";", "}", "/", "/", "verify", "the", "required", "parameter", "'", "byte", "'", "is", "set", "if", "(", "byte", "=", "=", "null", ")", "{", "throw", "new", "api", "exception", "(", "400", ",", "\"", "missing", "the", "required", "parameter", "'", "byte", "'", "when", "calling", "test", "endpoint", "parameters", "\"", ")", ";", "}", "/", "/", "create", "path", "and", "map", "variables", "string", "local", "var", "path", "=", "\"", "/", "fake", "\"", "replace", "all", "(", "\"", "\\", "\\", "{", "format", "\\", "\\", "}", "\"", ",", "\"", "json", "\"", ")", ";", "/", "/", "query", "params", "list", "<", "pair", ">", "local", "var", "query", "params", "=", "new", "array", "list", "<", "pair", ">", "(", ")", ";", "map", "<", "string", ",", "string", ">", "local", "var", "header", "params", "=", "new", "hash", "map", "<", "string", ",", "string", ">", "(", ")", ";", "map", "<", "string", ",", "string", ">", "local", "var", "cookie", "params", "=", "new", "hash", "map", "<", "string", ",", "string", ">", "(", ")", ";", "map", "<", "string", ",", "object", ">", "local", "var", "form", "params", "=", "new", "hash", "map", "<", "string", ",", "object", ">", "(", ")", ";", "if", "(", "integer", "!", "=", "null", ")", "local", "var", "form", "params", "put", "(", "\"", "integer", "\"", ",", "integer", ")", ";", "if", "(", "int", "3", "2", "!", "=", "null", ")", "local", "var", "form", "params", "put", "(", "\"", "int", "3", "2", "\"", ",", "int", "3", "2", ")", ";", "if", "(", "int", "6", "4", "!", "=", "null", ")", "local", "var", "form", "params", "put", "(", "\"", "int", "6", "4", "\"", ",", "int", "6", "4", ")", ";", "if", "(", "number", "!", "=", "null", ")", "local", "var", "form", "params", "put", "(", "\"", "number", "\"", ",", "number", ")", ";", "if", "(", "float", "!", "=", "null", ")", "local", "var", "form", "params", "put", "(", "\"", "float", "\"", ",", "float", ")", ";", "if", "(", "double", "!", "=", "null", ")", "local", "var", "form", "params", "put", "(", "\"", "double", "\"", ",", "double", ")", ";", "if", "(", "string", "!", "=", "null", ")", "local", "var", "form", "params", "put", "(", "\"", "string", "\"", ",", "string", ")", ";", "if", "(", "pattern", "without", "delimiter", "!", "=", "null", ")", "local", "var", "form", "params", "put", "(", "\"", "pattern", "without", "delimiter", "\"", ",", "pattern", "without", "delimiter", ")", ";", "if", "(", "byte", "!", "=", "null", ")", "local", "var", "form", "params", "put", "(", "\"", "byte", "\"", ",", "byte", ")", ";", "if", "(", "binary", "!", "=", "null", ")", "local", "var", "form", "params", "put", "(", "\"", "binary", "\"", ",", "binary", ")", ";", "if", "(", "date", "!", "=", "null", ")", "local", "var", "form", "params", "put", "(", "\"", "date", "\"", ",", "date", ")", ";", "if", "(", "date", "time", "!", "=", "null", ")", "local", "var", "form", "params", "put", "(", "\"", "date", "time", "\"", ",", "date", "time", ")", ";", "if", "(", "password", "!", "=", "null", ")", "local", "var", "form", "params", "put", "(", "\"", "password", "\"", ",", "password", ")", ";", "if", "(", "param", "callback", "!", "=", "null", ")", "local", "var", "form", "params", "put", "(", "\"", "callback", "\"", ",", "param", "callback", ")", ";", "final", "string", "[", "]", "local", "var", "accepts", "=", "{", "}", ";", "final", "string", "local", "var", "accept", "=", "api", "client", "select", "header", "accept", "(", "local", "var", "accepts", ")", ";", "final", "string", "[", "]", "local", "var", "content", "types", "=", "{", "\"", "application", "/", "x", "-", "www", "-", "form", "-", "urlencoded", "\"", "}", ";", "final", "string", "local", "var", "content", "type", "=", "api", "client", "select", "header", "content", "type", "(", "local", "var", "content", "types", ")", ";", "string", "[", "]", "local", "var", "auth", "names", "=", "new", "string", "[", "]", "{", "\"", "http", "basic", "test", "\"", "}", ";", "api", "client", "invoke", "a", "p", "i", "(", "local", "var", "path", ",", "\"", "post", "\"", ",", "local", "var", "query", "params", ",", "local", "var", "post", "body", ",", "local", "var", "header", "params", ",", "local", "var", "cookie", "params", ",", "local", "var", "form", "params", ",", "local", "var", "accept", ",", "local", "var", "content", "type", ",", "local", "var", "auth", "names", ",", "null", ")", ";", "}" ]

[ "return", "the", "list", "of", "media", "types", "this", "view", "supports", ",", "or", "an", "empty", "list" ]

[ "default", "list", "<", "media", "type", ">", "get", "supported", "media", "types", "(", ")", "{", "return", "collections", "empty", "list", "(", ")", ";", "}" ]

[ "get", "pet", "id" ]

[ "public", "long", "get", "pet", "id", "(", ")", "{", "return", "pet", "id", ";", "}" ]

[ "returns", "the", "resulting", "key", "of", "the", "handshake", ",", "if", "the", "handshake", "is", "completed", "note", "that", "the", "key", "data", "returned", "from", "the", "handshake", "may", "be", "more", "than", "the", "key", "length", "required", "for", "the", "record", "protocol", ",", "thus", "we", "need", "to", "truncate", "to", "the", "right", "size" ]

[ "public", "byte", "[", "]", "get", "key", "(", ")", "{", "if", "(", "result", "=", "=", "null", ")", "{", "return", "null", ";", "}", "if", "(", "result", "get", "key", "data", "(", ")", "size", "(", ")", "<", "key", "length", ")", "{", "throw", "new", "illegal", "state", "exception", "(", "\"", "could", "not", "get", "enough", "key", "data", "from", "the", "handshake", "\"", ")", ";", "}", "byte", "[", "]", "key", "=", "new", "byte", "[", "key", "length", "]", ";", "result", "get", "key", "data", "(", ")", "substring", "(", "0", ",", "key", "length", ")", "copy", "to", "(", "key", ",", "0", ")", ";", "return", "key", ";", "}" ]

[ "get", "prefix", "string" ]

[ "public", "string", "get", "prefix", "string", "(", ")", "{", "return", "prefix", "string", ";", "}" ]

[ "validate", "default", "ma", "wo", "configurations" ]

[ "public", "void", "test", "ma", "wo", "configuration", "(", ")", "{", "mawo", "configuration", "mawo", "conf", "=", "new", "mawo", "configuration", "(", ")", ";", "/", "/", "validate", "rpc", "server", "port", "assert", "assert", "equals", "(", "mawo", "conf", "get", "rpc", "server", "port", "(", ")", ",", "5120", ")", ";", "/", "/", "validate", "rpc", "hostname", "assert", "assert", "true", "(", "\"", "localhost", "\"", "equals", "(", "mawo", "conf", "get", "rpc", "host", "name", "(", ")", ")", ")", ";", "/", "/", "validate", "job", "queue", "storage", "conf", "boolean", "job", "queue", "storage", "=", "mawo", "conf", "get", "job", "queue", "storage", "enabled", "(", ")", ";", "assert", "assert", "true", "(", "job", "queue", "storage", ")", ";", "/", "/", "validate", "default", "teardown", "worker", "validity", "interval", "assert", "assert", "equals", "(", "mawo", "conf", "get", "teardown", "worker", "validity", "interval", "(", ")", ",", "120000", ")", ";", "/", "/", "validate", "zk", "related", "configs", "assert", "assert", "true", "(", "\"", "/", "tmp", "/", "mawo", "root", "\"", "equals", "(", "mawo", "conf", "get", "z", "k", "parent", "path", "(", ")", ")", ")", ";", "assert", "assert", "true", "(", "\"", "localhost", ":", "2181", "\"", "equals", "(", "mawo", "conf", "get", "z", "k", "address", "(", ")", ")", ")", ";", "assert", "assert", "equals", "(", "1000", ",", "mawo", "conf", "get", "z", "k", "retry", "interval", "m", "s", "(", ")", ")", ";", "assert", "assert", "equals", "(", "10000", ",", "mawo", "conf", "get", "z", "k", "session", "timeout", "m", "s", "(", ")", ")", ";", "assert", "assert", "equals", "(", "1000", ",", "mawo", "conf", "get", "z", "k", "retries", "num", "(", ")", ")", ";", "}" ]

[ "prevent", "the", "response", "from", "being", "cached", "only", "called", "in", "http", "1", "0", "compatibility", "mode", "see", "{", "@", "code", "https", ":", "www", "mnot", "netcache", "docs", "}" ]

[ "protected", "final", "void", "prevent", "caching", "(", "http", "servlet", "response", "response", ")", "{", "response", "set", "header", "(", "header", "pragma", ",", "\"", "no", "-", "cache", "\"", ")", ";", "if", "(", "this", "use", "expires", "header", ")", "{", "/", "/", "http", "1", "0", "expires", "header", "response", "set", "date", "header", "(", "header", "expires", ",", "1l", ")", ";", "}", "if", "(", "this", "use", "cache", "control", "header", ")", "{", "/", "/", "http", "1", "1", "cache", "-", "control", "header", ":", "\"", "no", "-", "cache", "\"", "is", "the", "standard", "value", ",", "/", "/", "\"", "no", "-", "store", "\"", "is", "necessary", "to", "prevent", "caching", "on", "firefox", "response", "set", "header", "(", "header", "cache", "control", ",", "\"", "no", "-", "cache", "\"", ")", ";", "if", "(", "this", "use", "cache", "control", "no", "store", ")", "{", "response", "add", "header", "(", "header", "cache", "control", ",", "\"", "no", "-", "store", "\"", ")", ";", "}", "}", "}" ]

[ "check", "the", "grant", "type", "against", "an", "expected", "grant", "type" ]

[ "public", "static", "boolean", "is", "grant", "type", "(", "final", "string", "type", ",", "final", "o", "auth", "2", "0", "grant", "types", "expected", "type", ")", "{", "return", "expected", "type", "name", "(", ")", "equals", "ignore", "case", "(", "type", ")", ";", "}" ]

[ "get", "userlogout", ":", "logs", "out", "current", "logged", "in", "user", "session" ]

[ "default", "response", "entity", "<", "void", ">", "logout", "user", "(", ")", "{", "return", "new", "response", "entity", "<", ">", "(", "http", "status", "not", "implemented", ")", ";", "}" ]

[ "attempt", "consuming", "using", "either", "static", "resource", "handlers", "or", "jar", "resource", "handlers" ]

[ "public", "boolean", "consume", "(", "http", "servlet", "request", "http", "request", ",", "http", "servlet", "response", "http", "response", ")", "throws", "i", "o", "exception", "{", "try", "{", "if", "(", "consume", "with", "file", "resource", "handlers", "(", "http", "request", ",", "http", "response", ")", ")", "{", "return", "true", ";", "}", "}", "catch", "(", "directory", "traversal", "directory", "traversal", "detection", "directory", "traversal", "detection", ")", "{", "http", "response", "set", "status", "(", "400", ")", ";", "http", "response", "get", "writer", "(", ")", "write", "(", "\"", "bad", "request", "\"", ")", ";", "http", "response", "get", "writer", "(", ")", "flush", "(", ")", ";", "log", "warn", "(", "directory", "traversal", "detection", "get", "message", "(", ")", "+", "\"", "directory", "traversal", "detection", "for", "path", ":", "\"", "+", "http", "request", "get", "path", "info", "(", ")", ")", ";", "}", "return", "false", ";", "}" ]

[ "tests", "that", "meters", "are", "properly", "reported", "via", "the", "j", "m", "x", "reporter" ]

[ "public", "void", "test", "meter", "reporting", "(", ")", "throws", "exception", "{", "metric", "registry", "impl", "registry", "=", "null", ";", "string", "meter", "name", "=", "\"", "meter", "\"", ";", "try", "{", "registry", "=", "new", "metric", "registry", "impl", "(", "metric", "registry", "configuration", "default", "metric", "registry", "configuration", "(", ")", ",", "collections", "singleton", "list", "(", "reporter", "setup", "for", "reporter", "(", "\"", "test", "\"", ",", "new", "j", "m", "x", "reporter", "(", "null", ")", ")", ")", ")", ";", "task", "manager", "metric", "group", "metric", "group", "=", "new", "task", "manager", "metric", "group", "(", "registry", ",", "\"", "localhost", "\"", ",", "\"", "tm", "id", "\"", ")", ";", "test", "meter", "meter", "=", "new", "test", "meter", "(", ")", ";", "metric", "group", "meter", "(", "meter", "name", ",", "meter", ")", ";", "m", "bean", "server", "m", "bean", "server", "=", "management", "factory", "get", "platform", "m", "bean", "server", "(", ")", ";", "object", "name", "object", "name", "=", "new", "object", "name", "(", "jmx", "domain", "prefix", "+", "\"", "taskmanager", "\"", "+", "meter", "name", ",", "j", "m", "x", "reporter", "generate", "jmx", "table", "(", "metric", "group", "get", "all", "variables", "(", ")", ")", ")", ";", "m", "bean", "info", "info", "=", "m", "bean", "server", "get", "m", "bean", "info", "(", "object", "name", ")", ";", "m", "bean", "attribute", "info", "[", "]", "attribute", "infos", "=", "info", "get", "attributes", "(", ")", ";", "assert", "equals", "(", "2", ",", "attribute", "infos", "length", ")", ";", "assert", "equals", "(", "meter", "get", "rate", "(", ")", ",", "m", "bean", "server", "get", "attribute", "(", "object", "name", ",", "\"", "rate", "\"", ")", ")", ";", "assert", "equals", "(", "meter", "get", "count", "(", ")", ",", "m", "bean", "server", "get", "attribute", "(", "object", "name", ",", "\"", "count", "\"", ")", ")", ";", "}", "finally", "{", "if", "(", "registry", "!", "=", "null", ")", "{", "registry", "shutdown", "(", ")", "get", "(", ")", ";", "}", "}", "}" ]

[ "atomically", "removes", "all", "of", "the", "elements", "from", "this", "queue", "the", "queue", "will", "be", "empty", "after", "this", "call", "returns" ]

[ "public", "void", "clear", "(", ")", "{", "final", "monitor", "monitor", "=", "this", "monitor", ";", "monitor", "enter", "(", ")", ";", "try", "{", "q", "clear", "(", ")", ";", "}", "finally", "{", "monitor", "leave", "(", ")", ";", "}", "}" ]

[ "model", "tests", "for", "number", "only" ]

[ "public", "void", "test", "number", "only", "(", ")", "{", "/", "/", "todo", ":", "test", "number", "only", "}" ]

[ "get", "network", "interceptor", "to", "add", "it", "to", "the", "http", "client", "to", "track", "download", "progress", "for", "async", "requests" ]

[ "private", "interceptor", "get", "progress", "interceptor", "(", ")", "{", "return", "new", "interceptor", "(", ")", "{", "@", "override", "public", "response", "intercept", "(", "interceptor", "chain", "chain", ")", "throws", "i", "o", "exception", "{", "final", "request", "request", "=", "chain", "request", "(", ")", ";", "final", "response", "original", "response", "=", "chain", "proceed", "(", "request", ")", ";", "if", "(", "request", "tag", "(", ")", "instanceof", "api", "callback", ")", "{", "final", "api", "callback", "callback", "=", "(", "api", "callback", ")", "request", "tag", "(", ")", ";", "return", "original", "response", "new", "builder", "(", ")", "body", "(", "new", "progress", "response", "body", "(", "original", "response", "body", "(", ")", ",", "callback", ")", ")", "build", "(", ")", ";", "}", "return", "original", "response", ";", "}", "}", ";", "}" ]

[ "set", "sentinel", "host", ",", "port", "and", "master", "id", "creates", "a", "new", "builder" ]

[ "public", "static", "redis", "connection", "config", "builder", "redis", "sentinel", "(", "string", "host", ",", "int", "port", ",", "string", "master", "id", ")", "{", "assert", "util", "not", "empty", "(", "host", ",", "\"", "host", "must", "not", "be", "empty", "\"", ")", ";", "assert", "util", "is", "true", "(", "is", "valid", "port", "(", "port", ")", ",", "string", "format", "(", "\"", "port", "out", "of", "range", ":", "%", "s", "\"", ",", "port", ")", ")", ";", "redis", "connection", "config", "builder", "builder", "=", "redis", "connection", "config", "builder", "(", ")", ";", "return", "builder", "with", "sentinel", "master", "id", "(", "master", "id", ")", "with", "redis", "sentinel", "(", "host", ",", "port", ")", ";", "}" ]

[ "copies", "special", "metadata", "hold", "by", "this", "instance", "to", "the", "provided", "instance" ]

[ "void", "copy", "meta", "(", "default", "binary", "memcache", "request", "dst", ")", "{", "super", "copy", "meta", "(", "dst", ")", ";", "dst", "reserved", "=", "reserved", ";", "}" ]

[ "creates", "a", "new", "fake", "project", "for", "the", "given", "user" ]

[ "public", "fake", "shared", "project", "create", "project", "(", "user", "user", ")", "throws", "i", "o", "exception", "{", "fake", "shared", "project", "existing", "project", "=", "projects", "by", "user", "get", "(", "user", ")", ";", "if", "(", "existing", "project", "!", "=", "null", ")", "{", "/", "/", "likely", "a", "programming", "error", "throw", "new", "illegal", "argument", "exception", "(", "\"", "attempted", "to", "create", "a", "second", "shared", "project", "for", "the", "same", "user", "\"", ")", ";", "}", "fake", "shared", "project", "project", "=", "new", "fake", "shared", "project", "(", "this", ",", "user", ")", ";", "projects", "by", "user", "put", "(", "user", ",", "project", ")", ";", "if", "(", "versioned", "file", "system", "=", "=", "null", ")", "{", "versioned", "file", "system", "=", "project", "get", "versioned", "file", "system", "(", ")", ";", "test", "utils", "set", "instance", "field", "(", "\"", "is", "shared", "\"", ",", "versioned", "file", "system", ",", "boolean", "true", ")", ";", "}", "return", "project", ";", "}" ]

[ "sets", "the", "reason", "for", "which", "the", "tasktracker", "was", "blacklisted" ]

[ "void", "set", "reason", "for", "black", "listing", "(", "string", "reason", "for", "black", "listing", ")", "{", "this", "reason", "for", "black", "listing", "=", "reason", "for", "black", "listing", ";", "}" ]

[ "returns", "a", "type", "that", "is", "functionally", "equal", "but", "not", "necessarily", "equal", "according", "to", "{", "@", "link", "object", "#", "equals", "(", "object", ")", "object", "equals", "(", ")", "}" ]

[ "public", "static", "type", "canonicalize", "(", "type", "type", ")", "{", "if", "(", "type", "instanceof", "parameterized", "type", "impl", "|", "|", "type", "instanceof", "generic", "array", "type", "impl", "|", "|", "type", "instanceof", "wildcard", "type", "impl", ")", "{", "return", "type", ";", "}", "else", "if", "(", "type", "instanceof", "parameterized", "type", ")", "{", "parameterized", "type", "p", "=", "(", "parameterized", "type", ")", "type", ";", "return", "new", "parameterized", "type", "impl", "(", "p", "get", "owner", "type", "(", ")", ",", "p", "get", "raw", "type", "(", ")", ",", "p", "get", "actual", "type", "arguments", "(", ")", ")", ";", "}", "else", "if", "(", "type", "instanceof", "generic", "array", "type", ")", "{", "generic", "array", "type", "g", "=", "(", "generic", "array", "type", ")", "type", ";", "return", "new", "generic", "array", "type", "impl", "(", "g", "get", "generic", "component", "type", "(", ")", ")", ";", "}", "else", "if", "(", "type", "instanceof", "class", "&", "&", "(", "(", "class", "<", "?", ">", ")", "type", ")", "is", "array", "(", ")", ")", "{", "class", "<", "?", ">", "c", "=", "(", "class", "<", "?", ">", ")", "type", ";", "return", "new", "generic", "array", "type", "impl", "(", "c", "get", "component", "type", "(", ")", ")", ";", "}", "else", "if", "(", "type", "instanceof", "wildcard", "type", ")", "{", "wildcard", "type", "w", "=", "(", "wildcard", "type", ")", "type", ";", "return", "new", "wildcard", "type", "impl", "(", "w", "get", "upper", "bounds", "(", ")", ",", "w", "get", "lower", "bounds", "(", ")", ")", ";", "}", "else", "{", "/", "/", "type", "is", "either", "serializable", "as", "-", "is", "or", "unsupported", "return", "type", ";", "}", "}" ]

[ "initialized", "the", "internals", "from", "a", "new", "chunk" ]

[ "public", "http", "post", "standard", "request", "decoder", "offer", "(", "http", "content", "content", ")", "{", "check", "destroyed", "(", ")", ";", "if", "(", "content", "instanceof", "last", "http", "content", ")", "{", "is", "last", "chunk", "=", "true", ";", "}", "byte", "buf", "buf", "=", "content", "content", "(", ")", ";", "if", "(", "undecoded", "chunk", "=", "=", "null", ")", "{", "undecoded", "chunk", "=", "is", "last", "chunk", "?", "/", "/", "take", "a", "slice", "instead", "of", "copying", "when", "the", "first", "chunk", "is", "also", "the", "last", "/", "/", "as", "undecoded", "chunk", "write", "bytes", "will", "never", "be", "called", "buf", "retained", "slice", "(", ")", ":", "/", "/", "maybe", "we", "should", "better", "not", "copy", "here", "for", "performance", "reasons", "but", "this", "will", "need", "/", "/", "more", "care", "by", "the", "caller", "to", "release", "the", "content", "in", "a", "correct", "manner", "later", "/", "/", "so", "maybe", "something", "to", "optimize", "on", "a", "later", "stage", "/", "/", "/", "/", "we", "are", "explicit", "allocate", "a", "buffer", "and", "not", "calling", "copy", "(", ")", "as", "otherwise", "it", "may", "set", "a", "max", "capacity", "/", "/", "which", "is", "not", "really", "usable", "for", "us", "as", "we", "may", "exceed", "it", "once", "we", "add", "more", "bytes", "buf", "alloc", "(", ")", "buffer", "(", "buf", "readable", "bytes", "(", ")", ")", "write", "bytes", "(", "buf", ")", ";", "}", "else", "{", "int", "read", "pos", "=", "undecoded", "chunk", "reader", "index", "(", ")", ";", "int", "writable", "=", "undecoded", "chunk", "writable", "bytes", "(", ")", ";", "int", "to", "write", "=", "buf", "readable", "bytes", "(", ")", ";", "if", "(", "undecoded", "chunk", "ref", "cnt", "(", ")", "=", "=", "1", "&", "&", "writable", "<", "to", "write", "&", "&", "read", "pos", "+", "writable", ">", "=", "to", "write", ")", "{", "undecoded", "chunk", "discard", "read", "bytes", "(", ")", ";", "}", "undecoded", "chunk", "write", "bytes", "(", "buf", ")", ";", "}", "parse", "body", "(", ")", ";", "return", "this", ";", "}" ]

[ "registers", "an", "ansi", "-", "control", "-", "code", "-", "allowing", "event", "handler", "with", "an", "ansi", "-", "stripping", "event", "handler", "that", "is", "already", "registered", "with", "the", "reporter", "the", "ansi", "-", "stripping", "handler", "can", "then", "be", "replaced", "with", "the", "ansi", "-", "allowing", "handler", "by", "calling", "{", "@", "code", "#", "switch", "to", "ansi", "allowing", "handler", "}", "which", "calls", "{", "@", "code", "remove", "handler", "}", "for", "the", "ansi", "-", "stripping", "handler", "and", "then", "{", "@", "code", "add", "handler", "}", "for", "the", "ansi", "-", "allowing", "handler" ]

[ "public", "synchronized", "void", "register", "ansi", "allowing", "handler", "(", "event", "handler", "ansi", "stripping", "handler", ",", "event", "handler", "ansi", "allowing", "handler", ")", "{", "this", "ansi", "allowing", "handler", "=", "ansi", "allowing", "handler", ";", "this", "ansi", "stripping", "handler", "=", "ansi", "stripping", "handler", ";", "ansi", "allowing", "handler", "registered", "=", "true", ";", "}" ]

[ "determine", "the", "last", "transaction", "id", "noted", "in", "this", "storage", "directory", "this", "txid", "is", "stored", "in", "a", "special", "seen", "txid", "file", "since", "it", "might", "not", "correspond", "to", "the", "latest", "image", "or", "edit", "log", "for", "example", ",", "an", "image", "-", "only", "directory", "will", "have", "this", "txid", "incremented", "when", "edits", "logs", "roll", ",", "even", "though", "the", "edits", "logs", "are", "in", "a", "different", "directory" ]

[ "static", "long", "read", "transaction", "id", "file", "(", "storage", "directory", "sd", ")", "throws", "i", "o", "exception", "{", "file", "txid", "file", "=", "get", "storage", "file", "(", "sd", ",", "name", "node", "file", "seen", "txid", ")", ";", "return", "persistent", "long", "file", "read", "file", "(", "txid", "file", ",", "0", ")", ";", "}" ]

[ "optional", ":", "indicates", "whether", "connections", "to", "this", "port", "should", "be", "secured", "using", "tls", "the", "value", "of", "this", "field", "determines", "how", "tls", "is", "enforced", "<", "code", ">", "istio", "networking", "v", "1alpha", "3", "server", "t", "l", "s", "options", "t", "l", "smode", "mode", "=", "2", ";", "<", "code", ">" ]

[ "public", "int", "get", "mode", "value", "(", ")", "{", "return", "mode", ";", "}" ]

[ "removes", "and", "returns", "the", "last", "item" ]

[ "public", "short", "pop", "(", ")", "{", "return", "items", "[", "-", "-", "size", "]", ";", "}" ]

[ "adds", "glyphs", "for", "the", "specified", "text" ]

[ "public", "glyph", "layout", "add", "text", "(", "char", "sequence", "str", ",", "float", "x", ",", "float", "y", ",", "float", "target", "width", ",", "int", "halign", ",", "boolean", "wrap", ")", "{", "return", "add", "text", "(", "str", ",", "x", ",", "y", ",", "0", ",", "str", "length", "(", ")", ",", "target", "width", ",", "halign", ",", "wrap", ",", "null", ")", ";", "}" ]

[ "get", "the", "cluster", "identifier" ]

[ "public", "string", "get", "cluster", "id", "(", ")", "{", "return", "this", "cluster", "id", ";", "}" ]

[ "allows", "subclasses", "to", "access", "the", "cache", "in", "{", "@", "link", "#", "draw", "(", "batch", ",", "float", ")", "}" ]

[ "protected", "bitmap", "font", "cache", "get", "bitmap", "font", "cache", "(", ")", "{", "return", "cache", ";", "}" ]

[ "sets", "flags", "for", "{", "@", "link", "adts", "extractor", "}", "instances", "created", "by", "the", "factory" ]

[ "public", "synchronized", "default", "extractors", "factory", "set", "adts", "extractor", "flags", "(", "@", "adts", "extractor", "flags", "int", "flags", ")", "{", "this", "adts", "flags", "=", "flags", ";", "return", "this", ";", "}" ]

[ "read", "the", "state", "of", "the", "change", "list" ]

[ "void", "restore", "undo", "redo", "state", "(", "save", "state", "save", "state", ")", "{", "change", "list", "clear", "(", ")", ";", "int", "number", "of", "changes", "=", "save", "state", "get", "int", "(", "number", "of", "changes", ",", "0", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "number", "of", "changes", ";", "i", "+", "+", ")", "{", "int", "block", "number", "=", "save", "state", "get", "int", "(", "block", "number", "+", "i", ",", "0", ")", ";", "big", "integer", "block", "offset", "=", "new", "big", "integer", "(", "save", "state", "get", "string", "(", "block", "offset", "+", "i", ",", "\"", "0", "\"", ")", ")", ";", "byte", "[", "]", "old", "value", "=", "save", "state", "get", "bytes", "(", "old", "value", "+", "i", ",", "null", ")", ";", "byte", "[", "]", "new", "value", "=", "save", "state", "get", "bytes", "(", "new", "value", "+", "i", ",", "null", ")", ";", "if", "(", "old", "value", "!", "=", "null", "&", "&", "new", "value", "!", "=", "null", ")", "{", "change", "list", "add", "(", "new", "byte", "edit", "info", "(", "block", "set", "get", "block", "start", "(", "block", "number", ")", ",", "block", "offset", ",", "old", "value", ",", "new", "value", ")", ")", ";", "}", "}", "}" ]

[ "an", "accessor", "to", "the", "raw", "value", "of", "the", "channel", "bytes", "output", "this", "method", "will", "not", "instantiate", "a", "new", "stream", "if", "one", "does", "not", "exist", "and", "this", "method", "will", "not", "reset", "the", "stream" ]

[ "protected", "final", "bytes", "stream", "output", "bytes", "output", "or", "null", "(", ")", "{", "return", "bytes", "out", ";", "}" ]

[ "called", "to", "add", "the", "actor", "to", "the", "tree", "when", "the", "node", "'", "s", "parent", "is", "expanded" ]

[ "protected", "int", "add", "to", "tree", "(", "tree", "<", "n", ",", "v", ">", "tree", ",", "int", "actor", "index", ")", "{", "tree", "add", "actor", "at", "(", "actor", "index", ",", "actor", ")", ";", "if", "(", "!", "expanded", ")", "return", "1", ";", "int", "child", "index", "=", "actor", "index", "+", "1", ";", "object", "[", "]", "children", "=", "this", "children", "items", ";", "for", "(", "int", "i", "=", "0", ",", "n", "=", "this", "children", "size", ";", "i", "<", "n", ";", "i", "+", "+", ")", "child", "index", "+", "=", "(", "(", "n", ")", "children", "[", "i", "]", ")", "add", "to", "tree", "(", "tree", ",", "child", "index", ")", ";", "return", "child", "index", "-", "actor", "index", ";", "}" ]

[ "test", "to", "verify", "the", "timeout", "of", "image", "upload" ]

[ "public", "void", "test", "image", "upload", "timeout", "(", ")", "throws", "exception", "{", "configuration", "conf", "=", "new", "hdfs", "configuration", "(", ")", ";", "n", "n", "storage", "mock", "storage", "=", "mockito", "mock", "(", "n", "n", "storage", "class", ")", ";", "http", "server", "2", "test", "server", "=", "http", "server", "functional", "test", "create", "server", "(", "\"", "hdfs", "\"", ")", ";", "try", "{", "test", "server", "add", "servlet", "(", "\"", "image", "transfer", "\"", ",", "image", "servlet", "path", "spec", ",", "test", "image", "transfer", "servlet", "class", ")", ";", "test", "server", "start", "(", ")", ";", "url", "server", "u", "r", "l", "=", "http", "server", "functional", "test", "get", "server", "u", "r", "l", "(", "test", "server", ")", ";", "/", "/", "set", "the", "timeout", "here", ",", "otherwise", "it", "will", "take", "default", "transfer", "fs", "image", "timeout", "=", "2000", ";", "file", "tmp", "dir", "=", "new", "file", "(", "new", "file", "system", "test", "helper", "(", ")", "get", "test", "root", "dir", "(", ")", ")", ";", "tmp", "dir", "mkdirs", "(", ")", ";", "file", "mock", "image", "file", "=", "file", "create", "temp", "file", "(", "\"", "image", "\"", ",", "\"", "\"", ",", "tmp", "dir", ")", ";", "file", "output", "stream", "image", "file", "=", "new", "file", "output", "stream", "(", "mock", "image", "file", ")", ";", "image", "file", "write", "(", "\"", "data", "\"", "get", "bytes", "(", ")", ")", ";", "image", "file", "close", "(", ")", ";", "mockito", "when", "(", "mock", "storage", "find", "image", "file", "(", "mockito", "any", "(", "name", "node", "file", "class", ")", ",", "mockito", "any", "long", "(", ")", ")", ")", "then", "return", "(", "mock", "image", "file", ")", ";", "mockito", "when", "(", "mock", "storage", "to", "colon", "separated", "string", "(", ")", ")", "then", "return", "(", "\"", "storage", ":", "info", ":", "string", "\"", ")", ";", "try", "{", "transfer", "fs", "image", "upload", "image", "from", "storage", "(", "server", "u", "r", "l", ",", "conf", ",", "mock", "storage", ",", "name", "node", "file", "image", ",", "1l", ")", ";", "fail", "(", "\"", "transfer", "image", "should", "fail", "with", "timeout", "\"", ")", ";", "}", "catch", "(", "socket", "timeout", "exception", "e", ")", "{", "assert", "equals", "(", "\"", "upload", "should", "timeout", "\"", ",", "\"", "read", "timed", "out", "\"", ",", "e", "get", "message", "(", ")", ")", ";", "}", "}", "finally", "{", "test", "server", "stop", "(", ")", ";", "}", "}" ]

[ "customize", "response", "specification" ]

[ "public", "upload", "file", "with", "required", "file", "oper", "resp", "spec", "(", "consumer", "<", "response", "spec", "builder", ">", "resp", "spec", "customizer", ")", "{", "resp", "spec", "customizer", "accept", "(", "resp", "spec", ")", ";", "return", "this", ";", "}" ]

[ "extracts", "a", "value", "identified", "by", "the", "given", "path", "in", "the", "source" ]

[ "public", "<", "t", ">", "t", "get", "value", "(", "string", "path", ")", "{", "return", "(", "t", ")", "object", "path", "eval", "(", "path", ",", "data", "(", ")", ")", ";", "}" ]

[ "ends", "the", "visit", "of", "{", "@", "link", "#", "current", "frame", "}", "by", "writing", "it", "in", "the", "stack", "map", "table", "entries", "and", "by", "updating", "the", "stack", "map", "table", "number", "of", "entries", "(", "except", "if", "the", "current", "frame", "is", "the", "first", "one", ",", "which", "is", "implicit", "in", "stack", "map", "table", ")", "then", "resets", "{", "@", "link", "#", "current", "frame", "}", "to", "{", "@", "literal", "null", "}" ]

[ "void", "visit", "frame", "end", "(", ")", "{", "if", "(", "previous", "frame", "!", "=", "null", ")", "{", "if", "(", "stack", "map", "table", "entries", "=", "=", "null", ")", "{", "stack", "map", "table", "entries", "=", "new", "byte", "vector", "(", ")", ";", "}", "put", "frame", "(", ")", ";", "+", "+", "stack", "map", "table", "number", "of", "entries", ";", "}", "previous", "frame", "=", "current", "frame", ";", "current", "frame", "=", "null", ";", "}" ]

[ "determine", "if", "this", "shared", "memory", "object", "is", "full" ]

[ "synchronized", "final", "public", "boolean", "is", "full", "(", ")", "{", "return", "allocated", "slots", "next", "clear", "bit", "(", "0", ")", ">", "=", "slots", "length", ";", "}" ]

[ "creates", "a", "{", "@", "code", "delta", "evictor", "}", "from", "the", "given", "threshold", "and", "{", "@", "code", "delta", "function", "}", "eviction", "is", "done", "before", "the", "window", "function" ]

[ "public", "static", "<", "t", ",", "w", "extends", "window", ">", "delta", "evictor", "<", "t", ",", "w", ">", "of", "(", "double", "threshold", ",", "delta", "function", "<", "t", ">", "delta", "function", ")", "{", "return", "new", "delta", "evictor", "<", ">", "(", "threshold", ",", "delta", "function", ")", ";", "}" ]

[ "creates", "the", "hierarchy", "using", "the", "information", "into", "the", "config" ]

[ "public", "static", "generic", "drawee", "hierarchy", "create", "drawee", "hierarchy", "(", "final", "context", "context", ",", "final", "config", "config", ")", "{", "fresco", "systrace", "begin", "section", "(", "\"", "drawee", "util", "#", "create", "drawee", "hierarchy", "\"", ")", ";", "generic", "drawee", "hierarchy", "builder", "builder", "=", "new", "generic", "drawee", "hierarchy", "builder", "(", "context", "get", "resources", "(", ")", ")", "set", "fade", "duration", "(", "config", "fade", "duration", "ms", ")", "set", "placeholder", "image", "(", "const", "placeholder", ")", "set", "failure", "image", "(", "const", "failure", ")", "set", "actual", "image", "scale", "type", "(", "scaling", "utils", "scale", "type", "fit", "center", ")", ";", "apply", "scale", "type", "(", "builder", ",", "config", ")", ";", "if", "(", "config", "use", "rounded", "corners", "|", "|", "config", "draw", "border", ")", "{", "final", "resources", "res", "=", "context", "get", "resources", "(", ")", ";", "final", "rounding", "params", "rounding", "params", "=", "new", "rounding", "params", "(", ")", ";", "if", "(", "config", "use", "rounded", "corners", ")", "{", "rounding", "params", "set", "rounding", "method", "(", "rounding", "params", "rounding", "method", "bitmap", "only", ")", ";", "rounding", "params", "set", "corners", "radius", "(", "res", "get", "dimension", "pixel", "size", "(", "r", "dimen", "drawee", "corner", "radius", ")", ")", ";", "rounding", "params", "set", "round", "as", "circle", "(", "config", "use", "rounded", "as", "circle", ")", ";", "}", "if", "(", "config", "draw", "border", ")", "{", "/", "/", "noinspection", "deprecation", "rounding", "params", "set", "border", "color", "(", "res", "get", "color", "(", "r", "color", "color", "primary", ")", ")", ";", "rounding", "params", "set", "border", "width", "(", "res", "get", "dimension", "pixel", "size", "(", "r", "dimen", "drawee", "border", "width", ")", ")", ";", "}", "builder", "set", "rounding", "params", "(", "rounding", "params", ")", ";", "}", "generic", "drawee", "hierarchy", "result", "=", "builder", "build", "(", ")", ";", "fresco", "systrace", "end", "section", "(", ")", ";", "return", "result", ";", "}" ]

[ "test", "the", "message", "from", "the", "elves" ]

[ "public", "void", "test", "message", "from", "elves", "(", ")", "{", "final", "var", "messenger", "=", "new", "messenger", "(", ")", ";", "test", "message", "(", "messenger", "message", "from", "elves", "(", ")", ",", "\"", "much", "wind", "pours", "from", "your", "mouth", "\"", ")", ";", "}" ]

[ "returns", "true", "if", "the", "this", "index", "should", "be", "searched", "throttled", "ie", "using", "the", "{", "@", "link", "org", "elasticsearch", "threadpool", "thread", "pool", "names", "#", "search", "throttled", "}", "thread", "-", "pool" ]

[ "public", "boolean", "is", "search", "throttled", "(", ")", "{", "return", "search", "throttled", ";", "}" ]

[ "specify", "whether", "external", "libraries", "will", "be", "added", "during", "the", "generation" ]

[ "public", "void", "set", "add", "external", "libs", "(", "boolean", "value", ")", "{", "is", "add", "external", "libs", "=", "value", ";", "}" ]

[ "determine", "if", "the", "specified", "component", "corresponds", "to", "a", "zero", "-", "length", "bit", "-", "field" ]

[ "public", "boolean", "is", "zero", "bit", "field", "component", "(", ")", ";" ]

[ "get", "snake", "case" ]

[ "public", "integer", "get", "snake", "case", "(", ")", "{", "return", "snake", "case", ";", "}" ]

[ "compiles", "and", "returns", "the", "result", "of", "{", "@", "code", "script", "}", "with", "access", "to", "{", "@", "code", "vars", "}", "and", "compile", "-", "time", "parameters" ]

[ "public", "object", "exec", "(", "string", "script", ",", "map", "<", "string", ",", "object", ">", "vars", ",", "map", "<", "string", ",", "string", ">", "compile", "params", ",", "boolean", "picky", ")", "{", "/", "/", "test", "for", "ambiguity", "errors", "before", "running", "the", "actual", "script", "if", "picky", "is", "true", "if", "(", "picky", ")", "{", "compiler", "settings", "picky", "settings", "=", "new", "compiler", "settings", "(", ")", ";", "picky", "settings", "set", "picky", "(", "true", ")", ";", "picky", "settings", "set", "regexes", "enabled", "(", "compiler", "settings", "regex", "enabled", "get", "(", "script", "engine", "settings", "(", ")", ")", ")", ";", "walker", "build", "painless", "tree", "(", "get", "test", "name", "(", ")", ",", "script", ",", "picky", "settings", ")", ";", "}", "/", "/", "test", "actual", "script", "execution", "painless", "test", "script", "factory", "factory", "=", "script", "engine", "compile", "(", "null", ",", "script", ",", "painless", "test", "script", "context", ",", "compile", "params", ")", ";", "painless", "test", "script", "test", "script", "=", "factory", "new", "instance", "(", "vars", "=", "=", "null", "?", "collections", "empty", "map", "(", ")", ":", "vars", ")", ";", "return", "test", "script", "execute", "(", ")", ";", "}" ]

[ "checks", "whether", "we", "can", "perform", "a", "write", "based", "on", "the", "required", "active", "shard", "count", "setting", "returns", "null", "if", "ok", "to", "proceed", ",", "or", "a", "string", "describing", "the", "reason", "to", "stop" ]

[ "protected", "string", "check", "active", "shard", "count", "(", ")", "{", "final", "shard", "id", "shard", "id", "=", "primary", "routing", "entry", "(", ")", "shard", "id", "(", ")", ";", "final", "active", "shard", "count", "wait", "for", "active", "shards", "=", "request", "wait", "for", "active", "shards", "(", ")", ";", "if", "(", "wait", "for", "active", "shards", "=", "=", "active", "shard", "count", "none", ")", "{", "return", "null", ";", "/", "/", "not", "waiting", "for", "any", "shards", "}", "final", "index", "shard", "routing", "table", "shard", "routing", "table", "=", "primary", "get", "replication", "group", "(", ")", "get", "routing", "table", "(", ")", ";", "if", "(", "wait", "for", "active", "shards", "enough", "shards", "active", "(", "shard", "routing", "table", ")", ")", "{", "return", "null", ";", "}", "else", "{", "final", "string", "resolved", "shards", "=", "wait", "for", "active", "shards", "=", "=", "active", "shard", "count", "all", "?", "integer", "to", "string", "(", "shard", "routing", "table", "shards", "(", ")", "size", "(", ")", ")", ":", "wait", "for", "active", "shards", "to", "string", "(", ")", ";", "logger", "trace", "(", "\"", "[", "{", "}", "]", "not", "enough", "active", "copies", "to", "meet", "shard", "count", "of", "[", "{", "}", "]", "(", "have", "{", "}", ",", "needed", "{", "}", ")", ",", "scheduling", "a", "retry", "op", "[", "{", "}", "]", ",", "\"", "+", "\"", "request", "[", "{", "}", "]", "\"", ",", "shard", "id", ",", "wait", "for", "active", "shards", ",", "shard", "routing", "table", "active", "shards", "(", ")", "size", "(", ")", ",", "resolved", "shards", ",", "op", "type", ",", "request", ")", ";", "return", "\"", "not", "enough", "active", "copies", "to", "meet", "shard", "count", "of", "[", "\"", "+", "wait", "for", "active", "shards", "+", "\"", "]", "(", "have", "\"", "+", "shard", "routing", "table", "active", "shards", "(", ")", "size", "(", ")", "+", "\"", ",", "needed", "\"", "+", "resolved", "shards", "+", "\"", ")", "\"", ";", "}", "}" ]

[ "block", "awaiting", "all", "outstanding", "uploads", "to", "complete" ]

[ "private", "list", "<", "part", "e", "tag", ">", "wait", "for", "all", "part", "uploads", "(", ")", "throws", "i", "o", "exception", "{", "log", "debug", "(", "\"", "waiting", "for", "{", "}", "uploads", "to", "complete", "\"", ",", "part", "e", "tags", "futures", "size", "(", ")", ")", ";", "try", "{", "return", "futures", "all", "as", "list", "(", "part", "e", "tags", "futures", ")", "get", "(", ")", ";", "}", "catch", "(", "interrupted", "exception", "ie", ")", "{", "log", "warn", "(", "\"", "interrupted", "part", "upload", "\"", ",", "ie", ")", ";", "thread", "current", "thread", "(", ")", "interrupt", "(", ")", ";", "return", "null", ";", "}", "catch", "(", "execution", "exception", "ee", ")", "{", "/", "/", "there", "is", "no", "way", "of", "recovering", "so", "abort", "/", "/", "cancel", "all", "part", "uploads", "log", "debug", "(", "\"", "while", "waiting", "for", "upload", "completion", "\"", ",", "ee", ")", ";", "/", "/", "abort", "multipartupload", "this", "abort", "(", ")", ";", "throw", "extract", "exception", "(", "\"", "multi", "-", "part", "upload", "with", "id", "'", "\"", "+", "upload", "id", "+", "\"", "'", "to", "\"", "+", "key", ",", "key", ",", "ee", ")", ";", "}", "}" ]

[ "get", "small", "snake" ]

[ "public", "string", "get", "small", "snake", "(", ")", "{", "return", "small", "snake", ";", "}" ]

[ "a", "filter", "for", "iterable", "<", "?", "extends", "has", "file", "type", ">", "that", "returns", "everything", "except", "the", "specified", "file", "type" ]

[ "public", "static", "<", "t", "extends", "has", "file", "type", ">", "iterable", "<", "t", ">", "except", "(", "final", "iterable", "<", "t", ">", "items", ",", "file", "type", "file", "type", ")", "{", "return", "iterables", "filter", "(", "items", ",", "predicates", "not", "(", "type", "matching", "predicate", "for", "(", "file", "type", ")", ")", ")", ";", "}" ]

[ "int", "to", "long", "conversion", "with", "zero", "-", "padding" ]

[ "private", "static", "long", "to", "6", "4", "(", "int", "i", ")", "{", "return", "i", "&", "0x", "f", "f", "f", "f", "f", "f", "f", "f", "l", ";", "}" ]

[ "copies", "all", "bytes", "from", "a", "url", "to", "an", "output", "stream" ]

[ "public", "static", "void", "copy", "(", "url", "from", ",", "output", "stream", "to", ")", "throws", "i", "o", "exception", "{", "as", "byte", "source", "(", "from", ")", "copy", "to", "(", "to", ")", ";", "}" ]

[ "failure", "handling", ":", "record", "the", "exception", "that", "triggered", "it", "-", "if", "there", "was", "not", "one", "already", "services", "are", "free", "to", "call", "this", "themselves" ]

[ "protected", "final", "void", "note", "failure", "(", "exception", "exception", ")", "{", "log", "debug", "(", "\"", "note", "failure", "\"", ",", "exception", ")", ";", "if", "(", "exception", "=", "=", "null", ")", "{", "/", "/", "make", "sure", "failure", "logic", "doesn", "'", "t", "itself", "cause", "problems", "return", ";", "}", "/", "/", "record", "the", "failure", "details", ",", "and", "log", "it", "synchronized", "(", "this", ")", "{", "if", "(", "failure", "cause", "=", "=", "null", ")", "{", "failure", "cause", "=", "exception", ";", "failure", "state", "=", "get", "service", "state", "(", ")", ";", "log", "info", "(", "\"", "service", "{", "}", "failed", "in", "state", "{", "}", "\"", ",", "get", "name", "(", ")", ",", "failure", "state", ",", "exception", ")", ";", "}", "}", "}" ]

[ "a", "simple", "way", "to", "create", "jar", "file", "using", "the", "jar", "creator", "class" ]

[ "public", "static", "void", "main", "(", "string", "[", "]", "args", ")", "{", "if", "(", "args", "length", "<", "1", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "create", "jar", "output", "[", "root", "directories", "]", "\"", ")", ";", "system", "exit", "(", "1", ")", ";", "}", "string", "output", "=", "args", "[", "0", "]", ";", "jar", "creator", "create", "jar", "=", "new", "jar", "creator", "(", "output", ")", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<", "args", "length", ";", "i", "+", "+", ")", "{", "create", "jar", "add", "directory", "(", "args", "[", "i", "]", ")", ";", "}", "create", "jar", "set", "compression", "(", "true", ")", ";", "create", "jar", "set", "normalize", "(", "true", ")", ";", "create", "jar", "set", "verbose", "(", "true", ")", ";", "long", "start", "=", "system", "current", "time", "millis", "(", ")", ";", "try", "{", "create", "jar", "execute", "(", ")", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "e", "print", "stack", "trace", "(", ")", ";", "system", "exit", "(", "1", ")", ";", "}", "long", "stop", "=", "system", "current", "time", "millis", "(", ")", ";", "system", "err", "println", "(", "(", "stop", "-", "start", ")", "+", "\"", "ms", "\"", ")", ";", "}" ]

[ "returns", "true", "if", "the", "supplied", "class", "includes", "an", "annotation", "of", "the", "given", "type" ]

[ "static", "public", "boolean", "is", "annotation", "present", "(", "class", "c", ",", "class", "<", "?", "extends", "java", "lang", "annotation", "annotation", ">", "annotation", "type", ")", "{", "return", "c", "is", "annotation", "present", "(", "annotation", "type", ")", ";", "}" ]

[ "this", "method", "resets", "the", "input", "!" ]

[ "public", "mutable", "object", "iterator", "<", "t", ">", "get", "iterator", "(", ")", "throws", "interrupted", "exception", ",", "i", "o", "exception", "{", "synchronized", "(", "this", "lock", ")", "{", "while", "(", "this", "exception", "=", "=", "null", "&", "&", "!", "this", "writing", "done", ")", "{", "this", "lock", "wait", "(", "5000", ")", ";", "}", "}", "if", "(", "this", "exception", "!", "=", "null", ")", "{", "throw", "new", "runtime", "exception", "(", "\"", "an", "error", "occurred", "creating", "the", "temp", "table", "\"", ",", "this", "exception", ")", ";", "}", "else", "if", "(", "this", "writing", "done", ")", "{", "final", "data", "input", "view", "in", "=", "this", "buffer", "flip", "(", ")", ";", "return", "new", "input", "view", "iterator", "<", ">", "(", "in", ",", "this", "serializer", ")", ";", "}", "else", "{", "return", "null", ";", "}", "}" ]

[ "identifying", "certificate", "for", "this", "host", "{", "@", "code", "key", "cert", "chain", "input", "stream", "}", "and", "{", "@", "code", "key", "input", "stream", "}", "may", "be", "{", "@", "code", "null", "}", "for", "client", "contexts", ",", "which", "disables", "mutual", "authentication" ]

[ "public", "ssl", "context", "builder", "key", "manager", "(", "input", "stream", "key", "cert", "chain", "input", "stream", ",", "input", "stream", "key", "input", "stream", ")", "{", "return", "key", "manager", "(", "key", "cert", "chain", "input", "stream", ",", "key", "input", "stream", ",", "null", ")", ";", "}" ]

[ "test", "that", "a", "dir", "two", "levels", "down", "has", "a", "list", "status", "(", ")", "call", "that", "works", "as", "expected" ]

[ "public", "void", "test", "directories", "lower", "down", "have", "matching", "file", "status", "(", ")", "throws", "exception", "{", "path", "test", "=", "path", "(", "\"", "/", "test", "/", "test", "directories", "lower", "down", "have", "matching", "file", "status", "\"", ")", ";", "fs", "delete", "(", "test", ",", "true", ")", ";", "mkdirs", "(", "test", ")", ";", "assert", "exists", "(", "\"", "created", "test", "sub", "directory", "\"", ",", "test", ")", ";", "file", "status", "[", "]", "statuses", "=", "fs", "list", "status", "(", "test", ")", ";", "string", "status", "string", "=", "status", "to", "string", "(", "test", "to", "string", "(", ")", ",", "statuses", ")", ";", "assert", "equals", "(", "\"", "wrong", "number", "of", "elements", "in", "file", "status", "\"", "+", "status", "string", ",", "0", ",", "statuses", "length", ")", ";", "}" ]

[ "specifies", "the", "border", "radius", "for", "the", "given", "corner" ]

[ "public", "builder", "radius", "px", "(", "@", "corner", "int", "corner", ",", "@", "px", "int", "radius", ")", "{", "check", "not", "built", "(", ")", ";", "if", "(", "corner", "<", "0", "|", "|", "corner", ">", "=", "radius", "count", ")", "{", "throw", "new", "illegal", "argument", "exception", "(", "\"", "given", "invalid", "corner", ":", "\"", "+", "corner", ")", ";", "}", "m", "border", "m", "radius", "[", "corner", "]", "=", "radius", ";", "return", "this", ";", "}" ]

[ "set", "the", "initial", "delay", "after", "a", "rejection", "before", "retrying", "request" ]

[ "public", "self", "set", "retry", "backoff", "initial", "time", "(", "time", "value", "retry", "backoff", "initial", "time", ")", "{", "this", "retry", "backoff", "initial", "time", "=", "retry", "backoff", "initial", "time", ";", "return", "self", "(", ")", ";", "}" ]

[ "set", "the", "path", "filter" ]

[ "public", "glob", "builder", "with", "path", "filtern", "(", "path", "filter", "path", "filter", ")", "{", "filter", "=", "path", "filter", ";", "return", "this", ";", "}" ]

[ "returns", "true", "if", "this", "reader", "will", "extract", "values", "in", "little", "endian", ",", "otherwise", "in", "big", "endian" ]

[ "public", "boolean", "is", "little", "endian", "(", ")", "{", "return", "converter", "instanceof", "g", "data", "converter", "l", "e", ";", "}" ]

[ "{", "@", "inherit", "doc", "}", "the", "default", "implementation", "returns", "the", "result", "of", "calling", "{", "@", "link", "#", "visit", "children", "}", "on", "{", "@", "code", "ctx", "}" ]

[ "@", "override", "public", "t", "visit", "refcasttype", "(", "painless", "parser", "refcasttype", "context", "ctx", ")", "{", "return", "visit", "children", "(", "ctx", ")", ";", "}" ]

[ "invokes", "\"", "static", "void", "register", "commands", "(", "command", "factory", ")", "\"", "on", "the", "given", "class", "this", "method", "abstracts", "the", "contract", "between", "the", "factory", "and", "the", "command", "class", "do", "not", "assume", "that", "directly", "invoking", "register", "commands", "on", "the", "given", "class", "will", "have", "the", "same", "effect" ]

[ "public", "void", "register", "commands", "(", "class", "<", "?", ">", "registrar", "class", ")", "{", "try", "{", "registrar", "class", "get", "method", "(", "\"", "register", "commands", "\"", ",", "command", "factory", "class", ")", "invoke", "(", "null", ",", "this", ")", ";", "}", "catch", "(", "exception", "e", ")", "{", "throw", "new", "runtime", "exception", "(", "string", "utils", "stringify", "exception", "(", "e", ")", ")", ";", "}", "}" ]

[ "called", "when", "a", "{", "@", "link", "metric", "}", "was", "removed" ]

[ "void", "notify", "of", "removed", "metric", "(", "metric", "metric", ",", "string", "metric", "name", ",", "metric", "group", "group", ")", ";" ]

[ "regression", "test", ":", "\"", "value", "in", "cycle", "depends", "on", "error", "\"", "we", "add", "another", "value", "that", "won", "'", "t", "finish", "building", "before", "the", "threadpool", "shuts", "down", ",", "to", "check", "that", "the", "cycle", "detection", "can", "handle", "unfinished", "values" ]

[ "public", "void", "cycle", "and", "error", "and", "other", "in", "bubble", "up", "(", ")", "throws", "exception", "{", "graph", "=", "new", "deterministic", "helper", "deterministic", "processable", "graph", "(", "new", "in", "memory", "graph", "impl", "(", ")", ")", ";", "tester", "=", "new", "graph", "tester", "(", ")", ";", "sky", "key", "error", "key", "=", "graph", "tester", "to", "sky", "key", "(", "\"", "error", "\"", ")", ";", "sky", "key", "cycle", "key", "=", "graph", "tester", "to", "sky", "key", "(", "\"", "cycle", "\"", ")", ";", "sky", "key", "mid", "key", "=", "graph", "tester", "to", "sky", "key", "(", "\"", "mid", "\"", ")", ";", "sky", "key", "top", "key", "=", "graph", "tester", "to", "sky", "key", "(", "\"", "top", "\"", ")", ";", "tester", "get", "or", "create", "(", "top", "key", ")", "add", "dependency", "(", "mid", "key", ")", "set", "computed", "value", "(", "concatenate", ")", ";", "/", "/", "we", "should", "add", "cycle", "key", "first", "and", "error", "key", "afterwards", "otherwise", "there", "is", "a", "chance", "that", "/", "/", "during", "error", "propagation", "cycle", "key", "will", "not", "be", "processed", ",", "and", "we", "will", "not", "detect", "the", "cycle", "tester", "get", "or", "create", "(", "mid", "key", ")", "add", "dependency", "(", "error", "key", ")", "add", "dependency", "(", "cycle", "key", ")", "set", "computed", "value", "(", "concatenate", ")", ";", "sky", "key", "other", "top", "=", "graph", "tester", "to", "sky", "key", "(", "\"", "other", "top", "\"", ")", ";", "count", "down", "latch", "top", "start", "and", "cycle", "finish", "=", "new", "count", "down", "latch", "(", "2", ")", ";", "/", "/", "in", "nokeep", "going", "mode", ",", "other", "top", "will", "wait", "until", "the", "threadpool", "has", "received", "an", "exception", ",", "/", "/", "then", "request", "its", "own", "dep", "this", "guarantees", "that", "there", "is", "a", "value", "that", "is", "not", "finished", "when", "/", "/", "cycle", "detection", "happens", "tester", "get", "or", "create", "(", "other", "top", ")", "set", "builder", "(", "new", "chained", "function", "(", "top", "start", "and", "cycle", "finish", ",", "new", "count", "down", "latch", "(", "0", ")", ",", "null", ",", "/", "*", "wait", "for", "exception", "=", "*", "/", "true", ",", "new", "string", "value", "(", "\"", "never", "returned", "\"", ")", ",", "immutable", "set", "<", "sky", "key", ">", "of", "(", "graph", "tester", "to", "sky", "key", "(", "\"", "dep", "that", "never", "builds", "\"", ")", ")", ")", ")", ";", "tester", "get", "or", "create", "(", "cycle", "key", ")", "set", "builder", "(", "new", "chained", "function", "(", "null", ",", "null", ",", "top", "start", "and", "cycle", "finish", ",", "/", "*", "wait", "for", "exception", "=", "*", "/", "false", ",", "new", "string", "value", "(", "\"", "\"", ")", ",", "immutable", "set", "<", "sky", "key", ">", "of", "(", "mid", "key", ")", ")", ")", ";", "/", "/", "error", "waits", "until", "other", "top", "starts", "and", "cycle", "finishes", ",", "to", "make", "sure", "other", "top", "will", "request", "/", "/", "its", "dep", "before", "the", "threadpool", "shuts", "down", "tester", "get", "or", "create", "(", "error", "key", ")", "set", "builder", "(", "new", "chained", "function", "(", "null", ",", "top", "start", "and", "cycle", "finish", ",", "null", ",", "/", "*", "wait", "for", "exception", "=", "*", "/", "false", ",", "null", ",", "immutable", "set", "<", "sky", "key", ">", "of", "(", ")", ")", ")", ";", "evaluation", "result", "<", "string", "value", ">", "result", "=", "eval", "(", "/", "*", "keep", "going", "=", "*", "/", "false", ",", "immutable", "set", "of", "(", "top", "key", ",", "other", "top", ")", ")", ";", "assert", "that", "(", "result", "error", "map", "(", ")", "key", "set", "(", ")", ")", "contains", "exactly", "(", "top", "key", ")", ";", "iterable", "<", "cycle", "info", ">", "cycle", "infos", "=", "result", "get", "error", "(", "top", "key", ")", "get", "cycle", "info", "(", ")", ";", "assert", "that", "(", "cycle", "infos", ")", "is", "not", "empty", "(", ")", ";", "cycle", "info", "cycle", "info", "=", "iterables", "get", "only", "element", "(", "cycle", "infos", ")", ";", "assert", "that", "(", "cycle", "info", "get", "path", "to", "cycle", "(", ")", ")", "contains", "exactly", "(", "top", "key", ")", ";", "assert", "that", "(", "cycle", "info", "get", "cycle", "(", ")", ")", "contains", "exactly", "(", "mid", "key", ",", "cycle", "key", ")", ";", "}" ]

[ "calls", "{", "@", "link", "#", "circle", "(", "float", ",", "float", ",", "float", ",", "int", ")", "}", "by", "estimating", "the", "number", "of", "segments", "needed", "for", "a", "smooth", "circle" ]

[ "public", "void", "circle", "(", "float", "x", ",", "float", "y", ",", "float", "radius", ")", "{", "circle", "(", "x", ",", "y", ",", "radius", ",", "math", "max", "(", "1", ",", "(", "int", ")", "(", "6", "*", "(", "float", ")", "math", "cbrt", "(", "radius", ")", ")", ")", ")", ";", "}" ]

[ "uninstall", "{", "@", "link", "google", "test", "security", "manager", "}", "if", "it", "is", "installed", "if", "it", "was", "installed", ",", "it", "will", "be", "reinstalled", "after", "the", "test", "completes" ]

[ "private", "void", "uninstall", "google", "test", "security", "manager", "(", ")", "{", "previous", "security", "manager", "=", "system", "get", "security", "manager", "(", ")", ";", "google", "test", "security", "manager", "uninstall", "if", "installed", "(", ")", ";", "if", "(", "previous", "security", "manager", "!", "=", "system", "get", "security", "manager", "(", ")", ")", "{", "was", "security", "manager", "installed", "=", "true", ";", "}", "}" ]

[ "1", "2", "3" ]

[ "void", "output", "to", "result", "(", ")", "{", "int", "index", "=", "0", ";", "for", "(", ";", "index", "<", "=", "this", "cursor", ";", ")", "{", "/", "/", "if", "(", "character", "util", "char", "useless", "=", "=", "this", "char", "types", "[", "index", "]", ")", "{", "index", "+", "+", ";", "continue", ";", "}", "/", "/", "lexeme", "path", "path", "=", "this", "path", "map", "get", "(", "index", ")", ";", "if", "(", "path", "!", "=", "null", ")", "{", "/", "/", "lexeme", "l", "=", "path", "poll", "first", "(", ")", ";", "while", "(", "l", "!", "=", "null", ")", "{", "this", "results", "add", "(", "l", ")", ";", "/", "/", "，", "，", "/", "*", "int", "inner", "index", "=", "index", "+", "1", ";", "for", "(", ";", "inner", "index", "<", "index", "+", "l", "get", "length", "(", ")", ";", "inner", "index", "+", "+", ")", "{", "lexeme", "inner", "l", "=", "path", "peek", "first", "(", ")", ";", "if", "(", "inner", "l", "!", "=", "null", "&", "&", "inner", "index", "=", "=", "inner", "l", "get", "begin", "(", ")", ")", "{", "this", "output", "single", "c", "j", "k", "(", "inner", "index", "-", "1", ")", ";", "}", "}", "*", "/", "/", "/", "index", "=", "l", "get", "begin", "(", ")", "+", "l", "get", "length", "(", ")", ";", "l", "=", "path", "poll", "first", "(", ")", ";", "if", "(", "l", "!", "=", "null", ")", "{", "/", "/", "，", "for", "(", ";", "index", "<", "l", "get", "begin", "(", ")", ";", "index", "+", "+", ")", "{", "this", "output", "single", "c", "j", "k", "(", "index", ")", ";", "}", "}", "}", "}", "else", "{", "/", "/", "/", "/", "this", "output", "single", "c", "j", "k", "(", "index", ")", ";", "index", "+", "+", ";", "}", "}", "/", "/", "this", "path", "map", "clear", "(", ")", ";", "}" ]

[ "creates", "an", "xml", "item", "this", "route", "creates", "an", "xml", "item" ]

[ "public", "single", "<", "void", ">", "rx", "create", "xml", "item", "(", "xml", "item", "xml", "item", ",", "api", "client", "auth", "info", "auth", "info", ")", "{", "return", "single", "create", "(", "new", "io", "vertx", "rx", "java", "single", "on", "subscribe", "adapter", "<", ">", "(", "fut", "-", ">", "delegate", "create", "xml", "item", "(", "xml", "item", ",", "auth", "info", ",", "fut", ")", ")", ")", ";", "}" ]

[ "this", "implementation", "calls", "{", "@", "link", "#", "init", "strategies", "}" ]

[ "protected", "void", "on", "refresh", "(", "application", "context", "context", ")", "{", "init", "strategies", "(", "context", ")", ";", "}" ]

[ "set", "the", "factory", "for", "concrete", "jca", "1", "5", "activation", "spec", "objects", ",", "creating", "jca", "activation", "specs", "based", "on", "{", "@", "link", "#", "set", "activation", "spec", "config", "jms", "activation", "spec", "config", "}", "objects", "this", "factory", "is", "dependent", "on", "the", "concrete", "jms", "provider", ",", "e", "g", "on", "active", "m", "q", "the", "default", "implementation", "simply", "guesses", "the", "activation", "spec", "class", "name", "from", "the", "provider", "'", "s", "class", "name", "(", "e", "g", "\"", "active", "m", "q", "resource", "adapter", "\"", "-", ">", "\"", "active", "m", "q", "activation", "spec", "\"", "in", "the", "same", "package", ")", ",", "and", "populates", "the", "activation", "spec", "properties", "as", "suggested", "by", "the", "jca", "1", "5", "specification", "(", "plus", "a", "couple", "of", "autodetected", "vendor", "-", "specific", "properties", ")" ]

[ "public", "void", "set", "activation", "spec", "factory", "(", "@", "nullable", "jms", "activation", "spec", "factory", "activation", "spec", "factory", ")", "{", "this", "activation", "spec", "factory", "=", "(", "activation", "spec", "factory", "!", "=", "null", "?", "activation", "spec", "factory", ":", "new", "default", "jms", "activation", "spec", "factory", "(", ")", ")", ";", "}" ]

[ "the", "symlink", "chain", "that", "is", "the", "root", "cause", "of", "the", "infinite", "expansion", "for", "example", ",", "suppose", "'", "a", "'", "-", ">", "'", "b", "'", "-", ">", "'", "c", "'", "-", ">", "'", "d", "'", "-", ">", "'", "cnope", "'", "the", "chain", "is", "'", "c", "'", ",", "'", "d", "'", ",", "'", "cnope", "'" ]

[ "public", "immutable", "list", "<", "rooted", "path", ">", "get", "chain", "(", ")", "{", "return", "chain", ";", "}" ]

[ "checks", "if", "the", "cluster", "state", "allows", "this", "node", "to", "add", "x", "-", "pack", "metadata", "to", "the", "cluster", "state", "see", "{", "@", "link", "#", "check", "ready", "for", "x", "pack", "custom", "metadata", "}", "for", "more", "details" ]

[ "public", "static", "boolean", "is", "ready", "for", "x", "pack", "custom", "metadata", "(", "cluster", "state", "cluster", "state", ")", "{", "return", "already", "contains", "x", "pack", "custom", "metadata", "(", "cluster", "state", ")", "|", "|", "nodes", "not", "ready", "for", "x", "pack", "custom", "metadata", "(", "cluster", "state", ")", "is", "empty", "(", ")", ";", "}" ]

[ "sets", "the", "setting", "with", "the", "provided", "setting", "key", "and", "a", "list", "of", "values" ]

[ "public", "builder", "put", "list", "(", "string", "setting", ",", "list", "<", "string", ">", "values", ")", "{", "remove", "(", "setting", ")", ";", "map", "put", "(", "setting", ",", "new", "array", "list", "<", ">", "(", "values", ")", ")", ";", "return", "this", ";", "}" ]

[ "displays", "format", "of", "commands" ]

[ "private", "static", "void", "print", "usage", "(", "string", "cmd", ")", "{", "if", "(", "\"", "-", "report", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "report", "]", "[", "-", "live", "]", "[", "-", "dead", "]", "[", "-", "decommissioning", "]", "\"", "+", "\"", "[", "-", "enteringmaintenance", "]", "[", "-", "inmaintenance", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "safemode", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "safemode", "enter", "|", "leave", "|", "get", "|", "wait", "|", "force", "exit", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "allow", "snapshot", "\"", "equals", "ignore", "case", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "allow", "snapshot", "<", "snapshot", "dir", ">", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "disallow", "snapshot", "\"", "equals", "ignore", "case", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "disallow", "snapshot", "<", "snapshot", "dir", ">", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "provision", "snapshot", "trash", "\"", "equals", "ignore", "case", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "provision", "snapshot", "trash", "<", "snapshot", "dir", ">", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "save", "namespace", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "save", "namespace", "[", "-", "before", "shutdown", "]", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "roll", "edits", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "[", "-", "roll", "edits", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "restore", "failed", "storage", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "restore", "failed", "storage", "true", "|", "false", "|", "check", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "refresh", "nodes", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "refresh", "nodes", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "finalize", "upgrade", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "finalize", "upgrade", "]", "\"", ")", ";", "}", "else", "if", "(", "rolling", "upgrade", "command", "matches", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "\"", "+", "rolling", "upgrade", "command", "usage", "+", "\"", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "upgrade", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "upgrade", "query", "|", "finalize", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "metasave", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "metasave", "filename", "]", "\"", ")", ";", "}", "else", "if", "(", "set", "quota", "command", "matches", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "\"", "+", "set", "quota", "command", "usage", "+", "\"", "]", "\"", ")", ";", "}", "else", "if", "(", "clear", "quota", "command", "matches", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "\"", "+", "clear", "quota", "command", "usage", "+", "\"", "]", "\"", ")", ";", "}", "else", "if", "(", "set", "space", "quota", "command", "matches", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "\"", "+", "set", "space", "quota", "command", "usage", "+", "\"", "]", "\"", ")", ";", "}", "else", "if", "(", "clear", "space", "quota", "command", "matches", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "\"", "+", "clear", "space", "quota", "command", "usage", "+", "\"", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "refresh", "service", "acl", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "refresh", "service", "acl", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "refresh", "user", "to", "groups", "mappings", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "refresh", "user", "to", "groups", "mappings", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "refresh", "super", "user", "groups", "configuration", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "refresh", "super", "user", "groups", "configuration", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "refresh", "call", "queue", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "refresh", "call", "queue", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "reconfig", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "reconfig", "<", "namenode", "|", "datanode", ">", "<", "host", ":", "ipc", "port", ">", "\"", "+", "\"", "<", "start", "|", "status", "|", "properties", ">", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "refresh", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "refresh", "<", "hostname", ":", "ipc", "port", ">", "\"", "+", "\"", "<", "resource", "identifier", ">", "[", "arg", "1", "argn", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "print", "topology", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "print", "topology", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "refresh", "namenodes", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "refresh", "namenodes", "datanode", "-", "host", ":", "ipc", "port", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "get", "volume", "report", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "get", "volume", "report", "datanode", "-", "host", ":", "ipc", "port", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "delete", "block", "pool", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "delete", "block", "pool", "datanode", "-", "host", ":", "ipc", "port", "blockpool", "id", "[", "force", "]", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "set", "balancer", "bandwidth", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "set", "balancer", "bandwidth", "<", "bandwidth", "in", "bytes", "per", "second", ">", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "get", "balancer", "bandwidth", "\"", "equals", "ignore", "case", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "get", "balancer", "bandwidth", "<", "datanode", "host", ":", "ipc", "port", ">", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "fetch", "image", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "fetch", "image", "<", "local", "directory", ">", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "shutdown", "datanode", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "shutdown", "datanode", "<", "datanode", "host", ":", "ipc", "port", ">", "[", "upgrade", "]", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "evict", "writers", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "evict", "writers", "<", "datanode", "host", ":", "ipc", "port", ">", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "get", "datanode", "info", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "get", "datanode", "info", "<", "datanode", "host", ":", "ipc", "port", ">", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "trigger", "block", "report", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "trigger", "block", "report", "[", "-", "incremental", "]", "<", "datanode", "host", ":", "ipc", "port", ">", "[", "-", "namenode", "<", "namenode", "host", ":", "ipc", "port", ">", "]", "]", "\"", ")", ";", "}", "else", "if", "(", "\"", "-", "list", "open", "files", "\"", "equals", "(", "cmd", ")", ")", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", "+", "\"", "[", "-", "list", "open", "files", "[", "-", "blocking", "decommission", "]", "[", "-", "path", "<", "path", ">", "]", "]", "\"", ")", ";", "}", "else", "{", "system", "err", "println", "(", "\"", "usage", ":", "hdfs", "dfsadmin", "\"", ")", ";", "system", "err", "println", "(", "\"", "note", ":", "administrative", "commands", "can", "only", "be", "run", "as", "the", "hdfs", "superuser", "\"", ")", ";", "system", "err", "println", "(", "common", "usage", "summary", ")", ";", "tool", "runner", "print", "generic", "command", "usage", "(", "system", "err", ")", ";", "}", "}" ]

[ "returns", "the", "checkout", "data", "corresponding", "to", "the", "specified", "checkout", "id", "null", "is", "returned", "if", "checkout", "id", "is", "not", "found" ]

[ "synchronized", "item", "checkout", "status", "get", "checkout", "(", "long", "checkout", "id", ")", "throws", "i", "o", "exception", "{", "validate", "(", ")", ";", "return", "checkouts", "get", "(", "checkout", "id", ")", ";", "}" ]

[ "@", "inherit", "doc" ]

[ "public", "class", "def", "read", "class", "def", "(", ")", "{", "ensure", "four", "bytes", "aligned", "(", "table", "of", "contents", "class", "defs", ",", "false", ")", ";", "return", "super", "read", "class", "def", "(", ")", ";", "}" ]

[ "sorts", "the", "elements", "of", "{", "@", "code", "array", "}", "between", "{", "@", "code", "from", "index", "}", "inclusive", "and", "{", "@", "code", "to", "index", "}", "exclusive", "in", "descending", "order", ",", "interpreting", "them", "as", "unsigned", "32", "-", "bit", "integers" ]

[ "public", "static", "void", "sort", "descending", "(", "int", "[", "]", "array", ",", "int", "from", "index", ",", "int", "to", "index", ")", "{", "check", "not", "null", "(", "array", ")", ";", "check", "position", "indexes", "(", "from", "index", ",", "to", "index", ",", "array", "length", ")", ";", "for", "(", "int", "i", "=", "from", "index", ";", "i", "<", "to", "index", ";", "i", "+", "+", ")", "{", "array", "[", "i", "]", "^", "=", "integer", "max", "value", ";", "}", "arrays", "sort", "(", "array", ",", "from", "index", ",", "to", "index", ")", ";", "for", "(", "int", "i", "=", "from", "index", ";", "i", "<", "to", "index", ";", "i", "+", "+", ")", "{", "array", "[", "i", "]", "^", "=", "integer", "max", "value", ";", "}", "}" ]

[ "set", "the", "{", "@", "link", "#", "start", "time", "}", ",", "when", "the", "first", "start", ",", "which", "means", "the", "first", "service", "provided" ]

[ "public", "exit", "span", "start", "(", ")", "{", "if", "(", "+", "+", "stack", "depth", "=", "=", "1", ")", "{", "super", "start", "(", ")", ";", "}", "return", "this", ";", "}" ]

[ "put", "faketest", "-", "query", "-", "paramters", "to", "test", "the", "collection", "format", "in", "query", "parameters" ]

[ "default", "response", "entity", "<", "void", ">", "test", "query", "parameter", "collection", "format", "(", "@", "not", "null", "@", "api", "param", "(", "value", "=", "\"", "\"", ",", "required", "=", "true", ")", "@", "valid", "@", "request", "param", "(", "value", "=", "\"", "pipe", "\"", ",", "required", "=", "true", ")", "list", "<", "string", ">", "pipe", ",", "@", "not", "null", "@", "api", "param", "(", "value", "=", "\"", "\"", ",", "required", "=", "true", ")", "@", "valid", "@", "request", "param", "(", "value", "=", "\"", "ioutil", "\"", ",", "required", "=", "true", ")", "list", "<", "string", ">", "ioutil", ",", "@", "not", "null", "@", "api", "param", "(", "value", "=", "\"", "\"", ",", "required", "=", "true", ")", "@", "valid", "@", "request", "param", "(", "value", "=", "\"", "http", "\"", ",", "required", "=", "true", ")", "list", "<", "string", ">", "http", ",", "@", "not", "null", "@", "api", "param", "(", "value", "=", "\"", "\"", ",", "required", "=", "true", ")", "@", "valid", "@", "request", "param", "(", "value", "=", "\"", "url", "\"", ",", "required", "=", "true", ")", "list", "<", "string", ">", "url", ",", "@", "not", "null", "@", "api", "param", "(", "value", "=", "\"", "\"", ",", "required", "=", "true", ")", "@", "valid", "@", "request", "param", "(", "value", "=", "\"", "context", "\"", ",", "required", "=", "true", ")", "list", "<", "string", ">", "context", ")", "{", "return", "get", "delegate", "(", ")", "test", "query", "parameter", "collection", "format", "(", "pipe", ",", "ioutil", ",", "http", ",", "url", ",", "context", ")", ";", "}" ]

[ "tests", "that", "track", "selector", "will", "select", "the", "lowest", "bitrate", "supported", "audio", "track", "when", "{", "@", "link", "parameters", "#", "force", "lowest", "bitrate", "}", "is", "set" ]

[ "public", "void", "select", "tracks", "within", "capabilities", "and", "force", "lowest", "bitrate", "select", "lower", "bitrate", "(", ")", "throws", "exception", "{", "format", "builder", "format", "builder", "=", "audio", "format", "build", "upon", "(", ")", ";", "format", "unsupported", "low", "bitrate", "format", "=", "format", "builder", "set", "id", "(", "\"", "unsupported", "\"", ")", "set", "average", "bitrate", "(", "5000", ")", "build", "(", ")", ";", "format", "lower", "bitrate", "format", "=", "format", "builder", "set", "id", "(", "\"", "lower", "\"", ")", "set", "average", "bitrate", "(", "15000", ")", "build", "(", ")", ";", "format", "higher", "bitrate", "format", "=", "format", "builder", "set", "id", "(", "\"", "higher", "\"", ")", "set", "average", "bitrate", "(", "30000", ")", "build", "(", ")", ";", "track", "group", "array", "track", "groups", "=", "wrap", "formats", "(", "unsupported", "low", "bitrate", "format", ",", "lower", "bitrate", "format", ",", "higher", "bitrate", "format", ")", ";", "map", "<", "string", ",", "integer", ">", "mapped", "capabilities", "=", "new", "hash", "map", "<", ">", "(", ")", ";", "mapped", "capabilities", "put", "(", "unsupported", "low", "bitrate", "format", "id", ",", "format", "exceeds", "capabilities", ")", ";", "mapped", "capabilities", "put", "(", "lower", "bitrate", "format", "id", ",", "format", "handled", ")", ";", "mapped", "capabilities", "put", "(", "higher", "bitrate", "format", "id", ",", "format", "handled", ")", ";", "renderer", "capabilities", "mapped", "audio", "renderer", "capabilities", "=", "new", "fake", "mapped", "renderer", "capabilities", "(", "c", "track", "type", "audio", ",", "mapped", "capabilities", ")", ";", "track", "selector", "set", "parameters", "(", "default", "parameters", "build", "upon", "(", ")", "set", "force", "lowest", "bitrate", "(", "true", ")", ")", ";", "track", "selector", "result", "result", "=", "track", "selector", "select", "tracks", "(", "new", "renderer", "capabilities", "[", "]", "{", "mapped", "audio", "renderer", "capabilities", "}", ",", "track", "groups", ",", "period", "id", ",", "timeline", ")", ";", "assert", "fixed", "selection", "(", "result", "selections", "get", "(", "0", ")", ",", "track", "groups", ",", "lower", "bitrate", "format", ")", ";", "}" ]

[ "inserts", "a", "parcelable", "value", "into", "the", "mapping", "of", "this", "bundle", ",", "replacing", "any", "existing", "value", "for", "the", "given", "key", "either", "key", "or", "value", "may", "be", "null" ]

[ "public", "postcard", "with", "parcelable", "(", "@", "nullable", "string", "key", ",", "@", "nullable", "parcelable", "value", ")", "{", "m", "bundle", "put", "parcelable", "(", "key", ",", "value", ")", ";", "return", "this", ";", "}" ]

[ "apply", "scale", "animation", "for", "the", "views", "'", "click" ]

[ "public", "static", "void", "apply", "pressed", "view", "scale", "(", "final", "view", "views", ")", "{", "apply", "pressed", "view", "scale", "(", "views", ",", "null", ")", ";", "}" ]

[ "transforms", "the", "specified", "point", "in", "the", "stage", "'", "s", "coordinates", "to", "the", "actor", "'", "s", "local", "coordinate", "system" ]

[ "public", "vector", "2", "stage", "to", "local", "coordinates", "(", "vector", "2", "stage", "coords", ")", "{", "if", "(", "parent", "!", "=", "null", ")", "parent", "stage", "to", "local", "coordinates", "(", "stage", "coords", ")", ";", "parent", "to", "local", "coordinates", "(", "stage", "coords", ")", ";", "return", "stage", "coords", ";", "}" ]

[ "given", "a", "block", "group", ",", "tell", "if", "any", "of", "the", "missing", "blocks", "can", "be", "recovered", ",", "to", "be", "called", "by", "e", "c", "manager" ]

[ "public", "boolean", "any", "recoverable", "(", "e", "c", "block", "group", "block", "group", ")", "{", "int", "erased", "count", "=", "block", "group", "get", "erased", "count", "(", ")", ";", "return", "erased", "count", ">", "0", "&", "&", "erased", "count", "<", "=", "get", "required", "num", "parity", "blocks", "(", ")", ";", "}" ]

[ "creates", "a", "new", "instance", "of", "the", "message", "digest", "to", "use", "for", "the", "blob", "key", "computation" ]

[ "static", "message", "digest", "create", "message", "digest", "(", ")", "{", "try", "{", "return", "message", "digest", "get", "instance", "(", "hashing", "algorithm", ")", ";", "}", "catch", "(", "no", "such", "algorithm", "exception", "e", ")", "{", "throw", "new", "runtime", "exception", "(", "\"", "cannot", "instantiate", "the", "message", "digest", "algorithm", "\"", "+", "hashing", "algorithm", ",", "e", ")", ";", "}", "}" ]

[ "sets", "the", "<", "code", ">", "enum", "integer", "<", "code", ">", "property" ]

[ "public", "enum", "test", "enum", "integer", "(", "enum", "integer", "enum", "enum", "integer", ")", "{", "this", "enum", "integer", "=", "enum", "integer", ";", "return", "this", ";", "}" ]

[ "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", "\"", ")", ";", "}" ]

[ "returns", "the", "number", "of", "first", "line", "of", "the", "attribute", "documentation", "in", "its", "declaration", "file" ]

[ "int", "get", "start", "line", "cnt", "(", ")", "{", "return", "start", "line", "cnt", ";", "}" ]

[ "remove", "this", "leaf", "from", "the", "tree" ]

[ "public", "fixed", "key", "node", "remove", "leaf", "(", ")", "throws", "i", "o", "exception", "{", "field", "key", "=", "get", "key", "field", "(", "0", ")", ";", "int", "prev", "buffer", "id", "=", "buffer", "get", "int", "(", "prev", "leaf", "id", "offset", ")", ";", "int", "next", "buffer", "id", "=", "buffer", "get", "int", "(", "next", "leaf", "id", "offset", ")", ";", "if", "(", "prev", "buffer", "id", ">", "=", "0", ")", "{", "fixed", "key", "record", "node", "prev", "node", "=", "(", "fixed", "key", "record", "node", ")", "node", "mgr", "get", "fixed", "key", "node", "(", "prev", "buffer", "id", ")", ";", "prev", "node", "get", "buffer", "(", ")", "put", "int", "(", "next", "leaf", "id", "offset", ",", "next", "buffer", "id", ")", ";", "}", "if", "(", "next", "buffer", "id", ">", "=", "0", ")", "{", "fixed", "key", "record", "node", "next", "node", "=", "(", "fixed", "key", "record", "node", ")", "node", "mgr", "get", "fixed", "key", "node", "(", "next", "buffer", "id", ")", ";", "next", "node", "get", "buffer", "(", ")", "put", "int", "(", "prev", "leaf", "id", "offset", ",", "prev", "buffer", "id", ")", ";", "}", "node", "mgr", "delete", "node", "(", "this", ")", ";", "if", "(", "parent", "=", "=", "null", ")", "{", "return", "null", ";", "}", "return", "parent", "delete", "child", "(", "key", ")", ";", "}" ]

[ "clean", "up", "of", "the", "builder", "for", "interrupted", "workflow", "this", "does", "nothing", "if", "{", "@", "link", "#", "close", "(", ")", "}", "was", "called", "successfully" ]

[ "public", "void", "clean", "up", "(", ")", "{", "if", "(", "m", "output", "jar", "!", "=", "null", ")", "{", "try", "{", "m", "output", "jar", "close", "(", ")", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "/", "/", "pass", "}", "}", "}" ]

[ "returns", "unprocessed", "arguments", "whereas", "{", "@", "link", "#", "get", "arguments", "(", ")", "}", "returns", "arguments", "already", "processed", "(", "e", "g", "varargs", "expended", ",", "etc", ")" ]

[ "object", "[", "]", "get", "raw", "arguments", "(", ")", ";" ]

[ "delegates", "to", "the", "{", "@", "link", "log", "#", "info", "(", "object", ")", "}", "method", "of", "the", "underlying", "{", "@", "link", "log", "}", "instance", "however", ",", "this", "form", "avoids", "superfluous", "object", "creation", "when", "the", "logger", "is", "disabled", "for", "level", "info" ]

[ "public", "void", "info", "(", "string", "format", ",", "object", "arguments", ")", "{", "if", "(", "logger", "is", "info", "enabled", "(", ")", ")", "{", "formatting", "tuple", "ft", "=", "message", "formatter", "array", "format", "(", "format", ",", "arguments", ")", ";", "logger", "info", "(", "ft", "get", "message", "(", ")", ",", "ft", "get", "throwable", "(", ")", ")", ";", "}", "}" ]

[ "returns", "an", "error", "if", "and", "only", "if", "an", "earlier", "call", "to", "{", "@", "link", "#", "evaluate", "}", "created", "it", ";", "null", "otherwise", "this", "method", "should", "only", "be", "used", "by", "tests", "that", "need", "to", "verify", "the", "presence", "of", "an", "error", "in", "the", "graph", "after", "an", "{", "@", "link", "#", "evaluate", "}", "call" ]

[ "error", "info", "get", "existing", "error", "for", "testing", "(", "sky", "key", "key", ")", "throws", "interrupted", "exception", ";" ]

[ "returns", "a", "new", "array", "containing", "the", "remaining", "values" ]

[ "public", "array", "<", "v", ">", "to", "array", "(", ")", "{", "return", "to", "array", "(", "new", "array", "(", "true", ",", "map", "size", ")", ")", ";", "}" ]

[ "popup", "the", "hello", "dialog" ]

[ "protected", "void", "announce", "(", "string", "message", ")", "{", "msg", "show", "info", "(", "get", "class", "(", ")", ",", "main", "panel", ",", "\"", "hello", "world", "\"", ",", "message", ")", ";", "}" ]