Datasets:

---

stojchet

/

base_prediction_dataset

like 0

[ "public", "Observable", "<", "Void", ">", "resizeAsync", "(", "String", "poolId", ",", "PoolResizeParameter", "poolResizeParameter", ")", "{", "return", "resizeWithServiceResponseAsync", "(", "poolId", ",", "poolResizeParameter", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponseWithHeaders", "<", "Void", ",", "PoolResizeHeaders", ">", ",", "Void", ">", "(", ")", "{", "@", "Override", "public", "Void", "call", "(", "ServiceResponseWithHeaders", "<", "Void", ",", "PoolResizeHeaders", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Changes", "the", "number", "of", "compute", "nodes", "that", "are", "assigned", "to", "a", "pool", ".", "You", "can", "only", "resize", "a", "pool", "when", "its", "allocation", "state", "is", "steady", ".", "If", "the", "pool", "is", "already", "resizing", "the", "request", "fails", "with", "status", "code", "409", ".", "When", "you", "resize", "a", "pool", "the", "pool", "s", "allocation", "state", "changes", "from", "steady", "to", "resizing", ".", "You", "cannot", "resize", "pools", "which", "are", "configured", "for", "automatic", "scaling", ".", "If", "you", "try", "to", "do", "this", "the", "Batch", "service", "returns", "an", "error", "409", ".", "If", "you", "resize", "a", "pool", "downwards", "the", "Batch", "service", "chooses", "which", "nodes", "to", "remove", ".", "To", "remove", "specific", "nodes", "use", "the", "pool", "remove", "nodes", "API", "instead", "." ]

[ "public", "void", "registerProperty", "(", "Object", "instance", ",", "String", "propertyName", ",", "boolean", "override", ")", "{", "if", "(", "registeredProperties", "==", "null", ")", "{", "registeredProperties", "=", "new", "HashMap", "<>", "(", ")", ";", "}", "if", "(", "instance", "==", "null", ")", "{", "registeredProperties", ".", "remove", "(", "propertyName", ")", ";", "}", "else", "{", "Object", "oldInstance", "=", "registeredProperties", ".", "get", "(", "propertyName", ")", ";", "PropertyProxy", "proxy", "=", "oldInstance", "instanceof", "PropertyProxy", "?", "(", "PropertyProxy", ")", "oldInstance", ":", "null", ";", "if", "(", "!", "override", "&&", "oldInstance", "!=", "null", "&&", "proxy", "==", "null", ")", "{", "return", ";", "}", "registeredProperties", ".", "put", "(", "propertyName", ",", "instance", ")", ";", "// If previous registrant was a property proxy, transfer its value to new registrant.", "if", "(", "proxy", "!=", "null", ")", "{", "try", "{", "proxy", ".", "getPropertyInfo", "(", ")", ".", "setPropertyValue", "(", "instance", ",", "proxy", ".", "getValue", "(", ")", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "createChainedException", "(", "\"Register Property\"", ",", "e", ",", "null", ")", ";", "}", "}", "}", "}" ]

[ "Registers", "a", "named", "property", "to", "the", "container", ".", "Using", "this", "a", "plugin", "can", "expose", "a", "property", "for", "serialization", "and", "deserialization", "." ]

[ "public", "static", "SuffixData", "createWithLCP", "(", "int", "[", "]", "input", ",", "int", "start", ",", "int", "length", ")", "{", "final", "ISuffixArrayBuilder", "builder", "=", "new", "DensePositiveDecorator", "(", "new", "ExtraTrailingCellsDecorator", "(", "defaultAlgorithm", "(", ")", ",", "3", ")", ")", ";", "return", "createWithLCP", "(", "input", ",", "start", ",", "length", ",", "builder", ")", ";", "}" ]

[ "Create", "a", "suffix", "array", "and", "an", "LCP", "array", "for", "a", "given", "input", "sequence", "of", "symbols", "." ]

[ "public", "PrivateKey", "getPrivateKey", "(", "String", "alias", ",", "String", "password", ")", "{", "Key", "key", "=", "getKey", "(", "alias", ",", "password", ")", ";", "if", "(", "key", "instanceof", "PrivateKey", ")", "{", "return", "(", "PrivateKey", ")", "key", ";", "}", "else", "{", "throw", "new", "IllegalStateException", "(", "format", "(", "\"Key with alias '%s' was not a private key, but was: %s\"", ",", "alias", ",", "key", ".", "getClass", "(", ")", ".", "getSimpleName", "(", ")", ")", ")", ";", "}", "}" ]

[ "Gets", "a", "asymmetric", "encryption", "private", "key", "from", "the", "key", "store" ]

[ "private", "void", "adjustApproximatedKNNDistances", "(", "MkCoPEntry", "entry", ",", "Map", "<", "DBID", ",", "KNNList", ">", "knnLists", ")", "{", "MkCoPTreeNode", "<", "O", ">", "node", "=", "getNode", "(", "entry", ")", ";", "if", "(", "node", ".", "isLeaf", "(", ")", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "node", ".", "getNumEntries", "(", ")", ";", "i", "++", ")", "{", "MkCoPLeafEntry", "leafEntry", "=", "(", "MkCoPLeafEntry", ")", "node", ".", "getEntry", "(", "i", ")", ";", "approximateKnnDistances", "(", "leafEntry", ",", "knnLists", ".", "get", "(", "leafEntry", ".", "getRoutingObjectID", "(", ")", ")", ")", ";", "}", "}", "else", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "node", ".", "getNumEntries", "(", ")", ";", "i", "++", ")", "{", "MkCoPEntry", "dirEntry", "=", "node", ".", "getEntry", "(", "i", ")", ";", "adjustApproximatedKNNDistances", "(", "dirEntry", ",", "knnLists", ")", ";", "}", "}", "ApproximationLine", "approx", "=", "node", ".", "conservativeKnnDistanceApproximation", "(", "settings", ".", "kmax", ")", ";", "entry", ".", "setConservativeKnnDistanceApproximation", "(", "approx", ")", ";", "}" ]

[ "Adjusts", "the", "knn", "distance", "in", "the", "subtree", "of", "the", "specified", "root", "entry", "." ]

[ "public", "Object", "toObject", "(", "String", "pString", ",", "Class", "pType", ",", "String", "pFormat", ")", "throws", "ConversionException", "{", "if", "(", "StringUtil", ".", "isEmpty", "(", "pString", ")", ")", "return", "null", ";", "TimeFormat", "format", ";", "try", "{", "if", "(", "pFormat", "==", "null", ")", "{", "// Use system default format\r", "format", "=", "TimeFormat", ".", "getInstance", "(", ")", ";", "}", "else", "{", "// Get format from cache\r", "format", "=", "getTimeFormat", "(", "pFormat", ")", ";", "}", "return", "format", ".", "parse", "(", "pString", ")", ";", "}", "catch", "(", "RuntimeException", "rte", ")", "{", "throw", "new", "ConversionException", "(", "rte", ")", ";", "}", "}" ]

[ "Converts", "the", "string", "to", "a", "time", "using", "the", "given", "format", "for", "parsing", "." ]

[ "public", "void", "setHeaderMargin", "(", "int", "l", ",", "int", "t", ",", "int", "r", ",", "int", "b", ")", "{", "mHeader", ".", "setMargin", "(", "l", ",", "t", ",", "r", ",", "b", ")", ";", "}" ]

[ "Set", "the", "margin", "of", "the", "header", "." ]

[ "public", "ADDRESST", "unregisterParticipant", "(", "ADDRESST", "address", ",", "EventListener", "entity", ")", "{", "synchronized", "(", "mutex", "(", ")", ")", "{", "removeListener", "(", "address", ")", ";", "this", ".", "participants", ".", "remove", "(", "entity", ".", "getID", "(", ")", ",", "address", ")", ";", "}", "return", "address", ";", "}" ]

[ "Remove", "a", "participant", "from", "this", "repository", "." ]

[ "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "// No values from static EMPTY class", "public", "void", "accept", "(", "CompositeRecordReader", ".", "JoinCollector", "jc", ",", "K", "key", ")", "throws", "IOException", "{", "if", "(", "hasNext", "(", ")", "&&", "0", "==", "cmp", ".", "compare", "(", "key", ",", "key", "(", ")", ")", ")", "{", "fillJoinCollector", "(", "createKey", "(", ")", ")", ";", "jc", ".", "add", "(", "id", ",", "getDelegate", "(", ")", ")", ";", "return", ";", "}", "jc", ".", "add", "(", "id", ",", "EMPTY", ")", ";", "}" ]

[ "If", "key", "provided", "matches", "that", "of", "this", "Composite", "give", "JoinCollector", "iterator", "over", "values", "it", "may", "emit", "." ]

[ "@", "CheckReturnValue", "public", "PermissionOverrideAction", "setPermissions", "(", "Collection", "<", "Permission", ">", "grantPermissions", ",", "Collection", "<", "Permission", ">", "denyPermissions", ")", "{", "setAllow", "(", "grantPermissions", ")", ";", "setDeny", "(", "denyPermissions", ")", ";", "return", "this", ";", "}" ]

[ "Combination", "of", "{", "@link", "#setAllow", "(", "java", ".", "util", ".", "Collection", ")", "}", "and", "{", "@link", "#setDeny", "(", "java", ".", "util", ".", "Collection", ")", "}", "<br", ">", "If", "a", "passed", "collection", "is", "{", "@code", "null", "}", "it", "resets", "the", "represented", "value", "to", "{", "@code", "0", "}", "-", "no", "permission", "specifics", "." ]

[ "public", "File", "createDockerBuildArchive", "(", "ImageConfiguration", "imageConfig", ",", "MojoParameters", "params", ",", "ArchiverCustomizer", "customizer", ")", "throws", "MojoExecutionException", "{", "File", "ret", "=", "createArchive", "(", "imageConfig", ".", "getName", "(", ")", ",", "imageConfig", ".", "getBuildConfiguration", "(", ")", ",", "params", ",", "log", ",", "customizer", ")", ";", "log", ".", "info", "(", "\"%s: Created docker source tar %s\"", ",", "imageConfig", ".", "getDescription", "(", ")", ",", "ret", ")", ";", "return", "ret", ";", "}" ]

[ "Create", "the", "tar", "file", "container", "the", "source", "for", "building", "an", "image", ".", "This", "tar", "can", "be", "used", "directly", "for", "uploading", "to", "a", "Docker", "daemon", "for", "creating", "the", "image" ]

[ "public", "static", "NodeList", "evaluateXpathExpression", "(", "String", "domStr", ",", "String", "xpathExpr", ")", "throws", "XPathExpressionException", ",", "IOException", "{", "Document", "dom", "=", "DomUtils", ".", "asDocument", "(", "domStr", ")", ";", "return", "evaluateXpathExpression", "(", "dom", ",", "xpathExpr", ")", ";", "}" ]

[ "Returns", "the", "list", "of", "nodes", "which", "match", "the", "expression", "xpathExpr", "in", "the", "String", "domStr", "." ]

[ "@", "Override", "public", "CPOption", "fetchByUUID_G", "(", "String", "uuid", ",", "long", "groupId", ")", "{", "return", "fetchByUUID_G", "(", "uuid", ",", "groupId", ",", "true", ")", ";", "}" ]

[ "Returns", "the", "cp", "option", "where", "uuid", "=", "&#63", ";", "and", "groupId", "=", "&#63", ";", "or", "returns", "<code", ">", "null<", "/", "code", ">", "if", "it", "could", "not", "be", "found", ".", "Uses", "the", "finder", "cache", "." ]

[ "protected", "void", "sendLink", "(", "final", "OtpErlangPid", "from", ",", "final", "OtpErlangPid", "dest", ")", "throws", "IOException", "{", "if", "(", "!", "connected", ")", "{", "throw", "new", "IOException", "(", "\"Not connected\"", ")", ";", "}", "@", "SuppressWarnings", "(", "\"resource\"", ")", "final", "OtpOutputStream", "header", "=", "new", "OtpOutputStream", "(", "headerLen", ")", ";", "// preamble: 4 byte length + \"passthrough\" tag", "header", ".", "write4BE", "(", "0", ")", ";", "// reserve space for length", "header", ".", "write1", "(", "passThrough", ")", ";", "header", ".", "write1", "(", "version", ")", ";", "// header", "header", ".", "write_tuple_head", "(", "3", ")", ";", "header", ".", "write_long", "(", "linkTag", ")", ";", "header", ".", "write_any", "(", "from", ")", ";", "header", ".", "write_any", "(", "dest", ")", ";", "// fix up length in preamble", "header", ".", "poke4BE", "(", "0", ",", "header", ".", "size", "(", ")", "-", "4", ")", ";", "do_send", "(", "header", ")", ";", "}" ]

[ "Create", "a", "link", "between", "the", "local", "node", "and", "the", "specified", "process", "on", "the", "remote", "node", ".", "If", "the", "link", "is", "still", "active", "when", "the", "remote", "process", "terminates", "an", "exit", "signal", "will", "be", "sent", "to", "this", "connection", ".", "Use", "{", "@link", "#sendUnlink", "unlink", "()", "}", "to", "remove", "the", "link", "." ]

[ "public", "void", "deleteProcessDefinition", "(", "ProcessDefinition", "processDefinition", ",", "String", "processDefinitionId", ",", "boolean", "cascadeToHistory", ",", "boolean", "cascadeToInstances", ",", "boolean", "skipCustomListeners", ",", "boolean", "skipIoMappings", ")", "{", "if", "(", "cascadeToHistory", ")", "{", "cascadeDeleteHistoryForProcessDefinition", "(", "processDefinitionId", ")", ";", "if", "(", "cascadeToInstances", ")", "{", "cascadeDeleteProcessInstancesForProcessDefinition", "(", "processDefinitionId", ",", "skipCustomListeners", ",", "skipIoMappings", ")", ";", "}", "}", "else", "{", "ProcessInstanceQueryImpl", "procInstQuery", "=", "new", "ProcessInstanceQueryImpl", "(", ")", ".", "processDefinitionId", "(", "processDefinitionId", ")", ";", "long", "processInstanceCount", "=", "getProcessInstanceManager", "(", ")", ".", "findProcessInstanceCountByQueryCriteria", "(", "procInstQuery", ")", ";", "if", "(", "processInstanceCount", "!=", "0", ")", "{", "throw", "LOG", ".", "deleteProcessDefinitionWithProcessInstancesException", "(", "processDefinitionId", ",", "processInstanceCount", ")", ";", "}", "}", "// remove related authorization parameters in IdentityLink table", "getIdentityLinkManager", "(", ")", ".", "deleteIdentityLinksByProcDef", "(", "processDefinitionId", ")", ";", "// remove timer start events:", "deleteTimerStartEventsForProcessDefinition", "(", "processDefinition", ")", ";", "//delete process definition from database", "getDbEntityManager", "(", ")", ".", "delete", "(", "ProcessDefinitionEntity", ".", "class", ",", "\"deleteProcessDefinitionsById\"", ",", "processDefinitionId", ")", ";", "// remove process definition from cache:", "Context", ".", "getProcessEngineConfiguration", "(", ")", ".", "getDeploymentCache", "(", ")", ".", "removeProcessDefinition", "(", "processDefinitionId", ")", ";", "deleteSubscriptionsForProcessDefinition", "(", "processDefinitionId", ")", ";", "// delete job definitions", "getJobDefinitionManager", "(", ")", ".", "deleteJobDefinitionsByProcessDefinitionId", "(", "processDefinition", ".", "getId", "(", ")", ")", ";", "}" ]

[ "Deletes", "the", "given", "process", "definition", "from", "the", "database", "and", "cache", ".", "If", "cascadeToHistory", "and", "cascadeToInstances", "is", "set", "to", "true", "it", "deletes", "the", "history", "and", "the", "process", "instances", "." ]

[ "@", "Nonnull", "public", "final", "Launcher", "decorateByPrefix", "(", "final", "String", "...", "prefix", ")", "{", "final", "Launcher", "outer", "=", "this", ";", "return", "new", "Launcher", "(", "outer", ")", "{", "@", "Override", "public", "boolean", "isUnix", "(", ")", "{", "return", "outer", ".", "isUnix", "(", ")", ";", "}", "@", "Override", "public", "Proc", "launch", "(", "ProcStarter", "starter", ")", "throws", "IOException", "{", "starter", ".", "commands", ".", "addAll", "(", "0", ",", "Arrays", ".", "asList", "(", "prefix", ")", ")", ";", "boolean", "[", "]", "masks", "=", "starter", ".", "masks", ";", "if", "(", "masks", "!=", "null", ")", "{", "starter", ".", "masks", "=", "prefix", "(", "masks", ")", ";", "}", "return", "outer", ".", "launch", "(", "starter", ")", ";", "}", "@", "Override", "public", "Channel", "launchChannel", "(", "String", "[", "]", "cmd", ",", "OutputStream", "out", ",", "FilePath", "workDir", ",", "Map", "<", "String", ",", "String", ">", "envVars", ")", "throws", "IOException", ",", "InterruptedException", "{", "return", "outer", ".", "launchChannel", "(", "prefix", "(", "cmd", ")", ",", "out", ",", "workDir", ",", "envVars", ")", ";", "}", "@", "Override", "public", "void", "kill", "(", "Map", "<", "String", ",", "String", ">", "modelEnvVars", ")", "throws", "IOException", ",", "InterruptedException", "{", "outer", ".", "kill", "(", "modelEnvVars", ")", ";", "}", "private", "String", "[", "]", "prefix", "(", "@", "Nonnull", "String", "[", "]", "args", ")", "{", "String", "[", "]", "newArgs", "=", "new", "String", "[", "args", ".", "length", "+", "prefix", ".", "length", "]", ";", "System", ".", "arraycopy", "(", "prefix", ",", "0", ",", "newArgs", ",", "0", ",", "prefix", ".", "length", ")", ";", "System", ".", "arraycopy", "(", "args", ",", "0", ",", "newArgs", ",", "prefix", ".", "length", ",", "args", ".", "length", ")", ";", "return", "newArgs", ";", "}", "private", "boolean", "[", "]", "prefix", "(", "@", "Nonnull", "boolean", "[", "]", "args", ")", "{", "boolean", "[", "]", "newArgs", "=", "new", "boolean", "[", "args", ".", "length", "+", "prefix", ".", "length", "]", ";", "System", ".", "arraycopy", "(", "args", ",", "0", ",", "newArgs", ",", "prefix", ".", "length", ",", "args", ".", "length", ")", ";", "return", "newArgs", ";", "}", "}", ";", "}" ]

[ "Returns", "a", "decorated", "{", "@link", "Launcher", "}", "that", "puts", "the", "given", "set", "of", "arguments", "as", "a", "prefix", "to", "any", "commands", "that", "it", "invokes", "." ]

[ "public", "static", "void", "validateClusterNodeCounts", "(", "final", "Cluster", "lhs", ",", "final", "Cluster", "rhs", ")", "{", "if", "(", "!", "lhs", ".", "getNodeIds", "(", ")", ".", "equals", "(", "rhs", ".", "getNodeIds", "(", ")", ")", ")", "{", "throw", "new", "VoldemortException", "(", "\"Node ids are not the same [ lhs cluster node ids (\"", "+", "lhs", ".", "getNodeIds", "(", ")", "+", "\") not equal to rhs cluster node ids (\"", "+", "rhs", ".", "getNodeIds", "(", ")", "+", "\") ]\"", ")", ";", "}", "}" ]

[ "Confirms", "that", "both", "clusters", "have", "the", "same", "number", "of", "nodes", "by", "comparing", "set", "of", "node", "Ids", "between", "clusters", "." ]

[ "public", "Observable", "<", "Void", ">", "beginDownloadUpdatesAsync", "(", "String", "deviceName", ",", "String", "resourceGroupName", ")", "{", "return", "beginDownloadUpdatesWithServiceResponseAsync", "(", "deviceName", ",", "resourceGroupName", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "Void", ">", ",", "Void", ">", "(", ")", "{", "@", "Override", "public", "Void", "call", "(", "ServiceResponse", "<", "Void", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Downloads", "the", "updates", "on", "a", "data", "box", "edge", "/", "gateway", "device", "." ]

[ "public", "void", "fitMultipleFiles", "(", "JavaPairRDD", "<", "String", ",", "String", ">", "documentsRdd", ")", "{", "/*\n All we want here, is to transform JavaPairRDD into JavaRDD<Sequence<VocabWord>>\n */", "validateConfiguration", "(", ")", ";", "broadcastEnvironment", "(", "new", "JavaSparkContext", "(", "documentsRdd", ".", "context", "(", ")", ")", ")", ";", "JavaRDD", "<", "Sequence", "<", "VocabWord", ">", ">", "sequenceRdd", "=", "documentsRdd", ".", "map", "(", "new", "KeySequenceConvertFunction", "(", "configurationBroadcast", ")", ")", ";", "super", ".", "fitSequences", "(", "sequenceRdd", ")", ";", "}" ]

[ "This", "method", "builds", "ParagraphVectors", "model", "expecting", "JavaPairRDD", "with", "key", "as", "label", "and", "value", "as", "document", "-", "in", "-", "a", "-", "string", "." ]

[ "public", "static", "CentralDogma", "forConfig", "(", "File", "configFile", ")", "throws", "IOException", "{", "requireNonNull", "(", "configFile", ",", "\"configFile\"", ")", ";", "return", "new", "CentralDogma", "(", "Jackson", ".", "readValue", "(", "configFile", ",", "CentralDogmaConfig", ".", "class", ")", ")", ";", "}" ]

[ "Creates", "a", "new", "instance", "from", "the", "given", "configuration", "file", "." ]

[ "public", "<", "T", ">", "T", "getProperty", "(", "String", "name", ",", "Class", "<", "T", ">", "type", ",", "T", "defaultValue", ")", "{", "Params", ".", "notNullOrEmpty", "(", "name", ",", "\"Property name\"", ")", ";", "Params", ".", "notNull", "(", "type", ",", "\"Property type\"", ")", ";", "String", "value", "=", "getProperty", "(", "name", ")", ";", "if", "(", "value", "!=", "null", ")", "{", "return", "converter", ".", "asObject", "(", "value", ",", "type", ")", ";", "}", "return", "defaultValue", ";", "}" ]

[ "Get", "configuration", "object", "property", "converter", "to", "requested", "type", "or", "default", "value", "if", "there", "is", "no", "property", "with", "given", "name", "." ]

[ "static", "private", "long", "skipForward", "(", "InputStream", "is", ",", "long", "toSkip", ")", "throws", "IOException", "{", "long", "eachSkip", "=", "0", ";", "long", "skipped", "=", "0", ";", "while", "(", "skipped", "!=", "toSkip", ")", "{", "eachSkip", "=", "is", ".", "skip", "(", "toSkip", "-", "skipped", ")", ";", "// check if EOF is reached", "if", "(", "eachSkip", "<=", "0", ")", "{", "if", "(", "is", ".", "read", "(", ")", "==", "-", "1", ")", "{", "return", "skipped", ";", "}", "else", "{", "skipped", "++", ";", "}", "}", "skipped", "+=", "eachSkip", ";", "}", "return", "skipped", ";", "}" ]

[ "Skips", "through", "the", "specified", "number", "of", "bytes", "from", "the", "stream", "until", "either", "EOF", "is", "reached", "or", "the", "specified", "number", "of", "bytes", "have", "been", "skipped" ]

[ "public", "static", "boolean", "isEndOfChunk", "(", "LabelTagType", "prev", ",", "LabelTagType", "cur", ")", "{", "if", "(", "prev", "==", "null", ")", "return", "false", ";", "return", "isEndOfChunk", "(", "prev", ".", "tag", ",", "prev", ".", "type", ",", "cur", ".", "tag", ",", "cur", ".", "type", ")", ";", "}" ]

[ "Returns", "whether", "a", "chunk", "ended", "between", "the", "previous", "and", "current", "token" ]

[ "public", "void", "beginDelete", "(", "String", "resourceGroupName", ",", "String", "ddosProtectionPlanName", ")", "{", "beginDeleteWithServiceResponseAsync", "(", "resourceGroupName", ",", "ddosProtectionPlanName", ")", ".", "toBlocking", "(", ")", ".", "single", "(", ")", ".", "body", "(", ")", ";", "}" ]

[ "Deletes", "the", "specified", "DDoS", "protection", "plan", "." ]

[ "public", "void", "addAll", "(", "String", "prefix", ",", "String", "[", "]", "strings", ")", "{", "if", "(", "strings", "==", "null", ")", "{", "return", ";", "}", "for", "(", "String", "string", ":", "strings", ")", "{", "if", "(", "filter", ".", "accept", "(", "string", ")", ")", "{", "list", ".", "add", "(", "prefix", "+", "string", ")", ";", "}", "}", "}" ]

[ "Add", "strings", "accepted", "by", "this", "filter", "pattern", "but", "prefixed", "with", "given", "string", ".", "Strings", "argument", "can", "come", "from", "{", "@link", "File#list", "()", "}", "and", "can", "be", "null", "in", "which", "case", "this", "method", "does", "nothing", ".", "This", "method", "accept", "a", "prefix", "argument", ";", "it", "is", "inserted", "at", "every", "string", "start", "before", "actually", "adding", "to", "strings", "list", "." ]

[ "public", "static", "String", "removeTrailing", "(", "String", "string", ",", "char", "c", ")", "{", "if", "(", "string", "==", "null", ")", "{", "return", "null", ";", "}", "final", "int", "lastCharIndex", "=", "string", ".", "length", "(", ")", "-", "1", ";", "return", "string", ".", "charAt", "(", "lastCharIndex", ")", "==", "c", "?", "string", ".", "substring", "(", "0", ",", "lastCharIndex", ")", ":", "string", ";", "}" ]

[ "Remove", "trailing", "character", "if", "exists", "." ]

[ "public", "GetIntegrationResult", "withRequestTemplates", "(", "java", ".", "util", ".", "Map", "<", "String", ",", "String", ">", "requestTemplates", ")", "{", "setRequestTemplates", "(", "requestTemplates", ")", ";", "return", "this", ";", "}" ]

[ "<p", ">", "Represents", "a", "map", "of", "Velocity", "templates", "that", "are", "applied", "on", "the", "request", "payload", "based", "on", "the", "value", "of", "the", "Content", "-", "Type", "header", "sent", "by", "the", "client", ".", "The", "content", "type", "value", "is", "the", "key", "in", "this", "map", "and", "the", "template", "(", "as", "a", "String", ")", "is", "the", "value", ".", "<", "/", "p", ">" ]

[ "@", "SuppressWarnings", "(", "\"deprecation\"", ")", "public", "static", "Intent", "newPickContactIntent", "(", "String", "scope", ")", "{", "Intent", "intent", ";", "if", "(", "isContacts2ApiSupported", "(", ")", ")", "{", "intent", "=", "new", "Intent", "(", "Intent", ".", "ACTION_PICK", ",", "Uri", ".", "parse", "(", "\"content://com.android.contacts/contacts\"", ")", ")", ";", "}", "else", "{", "intent", "=", "new", "Intent", "(", "Intent", ".", "ACTION_PICK", ",", "Contacts", ".", "People", ".", "CONTENT_URI", ")", ";", "}", "if", "(", "!", "TextUtils", ".", "isEmpty", "(", "scope", ")", ")", "{", "intent", ".", "setType", "(", "scope", ")", ";", "}", "return", "intent", ";", "}" ]

[ "Pick", "contact", "from", "phone", "book", "<p", "/", ">", "Examples", ":", "<p", "/", ">", "<code", ">", "<pre", ">", "//", "Select", "only", "from", "users", "with", "emails", "IntentUtils", ".", "pickContact", "(", "ContactsContract", ".", "CommonDataKinds", ".", "Email", ".", "CONTENT_TYPE", ")", ";", "<p", "/", ">", "//", "Select", "only", "from", "users", "with", "phone", "numbers", "on", "pre", "Eclair", "devices", "IntentUtils", ".", "pickContact", "(", "Contacts", ".", "Phones", ".", "CONTENT_TYPE", ")", ";", "<p", "/", ">", "//", "Select", "only", "from", "users", "with", "phone", "numbers", "on", "devices", "with", "Eclair", "and", "higher", "IntentUtils", ".", "pickContact", "(", "ContactsContract", ".", "CommonDataKinds", ".", "Phone", ".", "CONTENT_TYPE", ")", ";", "<", "/", "pre", ">", "<", "/", "code", ">" ]

[ "public", "static", "boolean", "isPresent", "(", "String", "name", ",", "@", "Nullable", "ClassLoader", "classLoader", ")", "{", "return", "forName", "(", "name", ",", "classLoader", ")", ".", "isPresent", "(", ")", ";", "}" ]

[ "Check", "whether", "the", "given", "class", "is", "present", "in", "the", "given", "classloader", "." ]

[ "@", "Override", "public", "String", "getReverseRouteFor", "(", "Class", "<", "?", "extends", "Controller", ">", "clazz", ",", "String", "method", ")", "{", "return", "getReverseRouteFor", "(", "clazz", ",", "method", ",", "null", ")", ";", "}" ]

[ "Gets", "the", "url", "of", "the", "route", "handled", "by", "the", "specified", "action", "method", ".", "The", "action", "does", "not", "takes", "parameters", ".", "This", "implementation", "delegates", "to", "{", "@link", "#getReverseRouteFor", "(", "java", ".", "lang", ".", "Class", "String", "java", ".", "util", ".", "Map", ")", "}", "." ]

[ "public", "MuleMessage", "doHttpSendRequest", "(", "String", "url", ",", "String", "method", ",", "String", "payload", ",", "String", "contentType", ")", "{", "Map", "<", "String", ",", "String", ">", "properties", "=", "new", "HashMap", "<", "String", ",", "String", ">", "(", ")", ";", "properties", ".", "put", "(", "\"http.method\"", ",", "method", ")", ";", "properties", ".", "put", "(", "\"Content-Type\"", ",", "contentType", ")", ";", "MuleMessage", "response", "=", "send", "(", "url", ",", "payload", ",", "properties", ")", ";", "return", "response", ";", "}" ]

[ "Perform", "a", "HTTP", "call", "sending", "information", "to", "the", "server", "using", "POST", "or", "PUT" ]

[ "public", "static", "final", "Date", "getFinishDate", "(", "byte", "[", "]", "data", ",", "int", "offset", ")", "{", "Date", "result", ";", "long", "days", "=", "getShort", "(", "data", ",", "offset", ")", ";", "if", "(", "days", "==", "0x8000", ")", "{", "result", "=", "null", ";", "}", "else", "{", "result", "=", "DateHelper", ".", "getDateFromLong", "(", "EPOCH", "+", "(", "(", "days", "-", "1", ")", "*", "DateHelper", ".", "MS_PER_DAY", ")", ")", ";", "}", "return", "(", "result", ")", ";", "}" ]

[ "Retrieve", "a", "finish", "date", "." ]

[ "public", "Observable", "<", "ClusterConfigurationsInner", ">", "listAsync", "(", "String", "resourceGroupName", ",", "String", "clusterName", ")", "{", "return", "listWithServiceResponseAsync", "(", "resourceGroupName", ",", "clusterName", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "ClusterConfigurationsInner", ">", ",", "ClusterConfigurationsInner", ">", "(", ")", "{", "@", "Override", "public", "ClusterConfigurationsInner", "call", "(", "ServiceResponse", "<", "ClusterConfigurationsInner", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Gets", "all", "configuration", "information", "for", "an", "HDI", "cluster", "." ]

[ "public", "Vector4f", "fma", "(", "Vector4fc", "a", ",", "Vector4fc", "b", ")", "{", "return", "fma", "(", "a", ",", "b", ",", "thisOrNew", "(", ")", ")", ";", "}" ]

[ "Add", "the", "component", "-", "wise", "multiplication", "of", "<code", ">", "a", "*", "b<", "/", "code", ">", "to", "this", "vector", "." ]

[ "public", "void", "reconfigure", "(", "final", "String", "config", ")", "{", "try", "{", "final", "File", "tempFile", "=", "File", ".", "createTempFile", "(", "\"nginx\"", ",", "\".conf\"", ")", ";", "try", "{", "FileHelper", ".", "write", "(", "tempFile", ",", "config", ")", ";", "final", "Execed", "process", "=", "Exec", ".", "rootUtility", "(", "new", "File", "(", "binPath", ",", "\"nginx-reconfigure\"", ")", ".", "getAbsolutePath", "(", ")", ",", "tempFile", ".", "getAbsolutePath", "(", ")", ")", ";", "process", ".", "waitForExit", "(", "new", "Timeout", "(", "30", ",", "TimeUnit", ".", "SECONDS", ")", ".", "start", "(", ")", ",", "0", ")", ";", "}", "finally", "{", "FileUtils", ".", "deleteQuietly", "(", "tempFile", ")", ";", "}", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "new", "RuntimeException", "(", "\"Error executing nginx-reload command\"", ",", "e", ")", ";", "}", "reload", "(", ")", ";", "}" ]

[ "Rewrite", "the", "nginx", "site", "configuration", "and", "reload" ]

[ "public", "static", "void", "setScreenOffTimeout", "(", "Context", "context", ",", "int", "millis", ")", "{", "Settings", ".", "System", ".", "putInt", "(", "context", ".", "getContentResolver", "(", ")", ",", "Settings", ".", "System", ".", "SCREEN_OFF_TIMEOUT", ",", "millis", ")", ";", "}" ]

[ "@param", "context", "@param", "millis", "Time", "for", "screen", "to", "turn", "off", ".", "Setting", "this", "value", "to", "-", "1", "will", "prohibit", "screen", "from", "turning", "off" ]

[ "static", "KeyStore", "buildKeyStore", "(", "X509Certificate", "[", "]", "certChain", ",", "PrivateKey", "key", ",", "char", "[", "]", "keyPasswordChars", ")", "throws", "KeyStoreException", ",", "NoSuchAlgorithmException", ",", "CertificateException", ",", "IOException", "{", "KeyStore", "ks", "=", "KeyStore", ".", "getInstance", "(", "KeyStore", ".", "getDefaultType", "(", ")", ")", ";", "ks", ".", "load", "(", "null", ",", "null", ")", ";", "ks", ".", "setKeyEntry", "(", "ALIAS", ",", "key", ",", "keyPasswordChars", ",", "certChain", ")", ";", "return", "ks", ";", "}" ]

[ "Generates", "a", "new", "{", "@link", "KeyStore", "}", "." ]

[ "public", "Observable", "<", "Page", "<", "SyncGroupLogPropertiesInner", ">", ">", "listLogsAsync", "(", "final", "String", "resourceGroupName", ",", "final", "String", "serverName", ",", "final", "String", "databaseName", ",", "final", "String", "syncGroupName", ",", "final", "String", "startTime", ",", "final", "String", "endTime", ",", "final", "String", "type", ",", "final", "String", "continuationToken", ")", "{", "return", "listLogsWithServiceResponseAsync", "(", "resourceGroupName", ",", "serverName", ",", "databaseName", ",", "syncGroupName", ",", "startTime", ",", "endTime", ",", "type", ",", "continuationToken", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "Page", "<", "SyncGroupLogPropertiesInner", ">", ">", ",", "Page", "<", "SyncGroupLogPropertiesInner", ">", ">", "(", ")", "{", "@", "Override", "public", "Page", "<", "SyncGroupLogPropertiesInner", ">", "call", "(", "ServiceResponse", "<", "Page", "<", "SyncGroupLogPropertiesInner", ">", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Gets", "a", "collection", "of", "sync", "group", "logs", "." ]

[ "public", "boolean", "isSubClassOf", "(", "TypeFinder", "typeFinder", ",", "String", "subClass", ",", "String", "superClass", ")", "throws", "JavaModelException", "{", "final", "SuperTypeIterator", "typeIterator", "=", "new", "SuperTypeIterator", "(", "typeFinder", ",", "false", ",", "subClass", ")", ";", "while", "(", "typeIterator", ".", "hasNext", "(", ")", ")", "{", "final", "IType", "type", "=", "typeIterator", ".", "next", "(", ")", ";", "if", "(", "Objects", ".", "equals", "(", "type", ".", "getFullyQualifiedName", "(", ")", ",", "superClass", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Replies", "if", "the", "given", "type", "is", "a", "subclass", "of", "the", "second", "type", "." ]

[ "private", "void", "processActivityCodes", "(", "APIBusinessObjects", "apibo", ",", "ProjectType", "project", ")", "{", "ActivityCodeContainer", "container", "=", "m_projectFile", ".", "getActivityCodes", "(", ")", ";", "Map", "<", "Integer", ",", "ActivityCode", ">", "map", "=", "new", "HashMap", "<", "Integer", ",", "ActivityCode", ">", "(", ")", ";", "List", "<", "ActivityCodeTypeType", ">", "types", "=", "new", "ArrayList", "<", "ActivityCodeTypeType", ">", "(", ")", ";", "types", ".", "addAll", "(", "apibo", ".", "getActivityCodeType", "(", ")", ")", ";", "types", ".", "addAll", "(", "project", ".", "getActivityCodeType", "(", ")", ")", ";", "for", "(", "ActivityCodeTypeType", "type", ":", "types", ")", "{", "ActivityCode", "code", "=", "new", "ActivityCode", "(", "type", ".", "getObjectId", "(", ")", ",", "type", ".", "getName", "(", ")", ")", ";", "container", ".", "add", "(", "code", ")", ";", "map", ".", "put", "(", "code", ".", "getUniqueID", "(", ")", ",", "code", ")", ";", "}", "List", "<", "ActivityCodeType", ">", "typeValues", "=", "new", "ArrayList", "<", "ActivityCodeType", ">", "(", ")", ";", "typeValues", ".", "addAll", "(", "apibo", ".", "getActivityCode", "(", ")", ")", ";", "typeValues", ".", "addAll", "(", "project", ".", "getActivityCode", "(", ")", ")", ";", "for", "(", "ActivityCodeType", "typeValue", ":", "typeValues", ")", "{", "ActivityCode", "code", "=", "map", ".", "get", "(", "typeValue", ".", "getCodeTypeObjectId", "(", ")", ")", ";", "if", "(", "code", "!=", "null", ")", "{", "ActivityCodeValue", "value", "=", "code", ".", "addValue", "(", "typeValue", ".", "getObjectId", "(", ")", ",", "typeValue", ".", "getCodeValue", "(", ")", ",", "typeValue", ".", "getDescription", "(", ")", ")", ";", "m_activityCodeMap", ".", "put", "(", "value", ".", "getUniqueID", "(", ")", ",", "value", ")", ";", "}", "}", "}" ]

[ "Process", "activity", "code", "data", "." ]

[ "public", "SyntacticCategory", "assignAllFeatures", "(", "String", "value", ")", "{", "Set", "<", "Integer", ">", "featureVars", "=", "Sets", ".", "newHashSet", "(", ")", ";", "getAllFeatureVariables", "(", "featureVars", ")", ";", "Map", "<", "Integer", ",", "String", ">", "valueMap", "=", "Maps", ".", "newHashMap", "(", ")", ";", "for", "(", "Integer", "var", ":", "featureVars", ")", "{", "valueMap", ".", "put", "(", "var", ",", "value", ")", ";", "}", "return", "assignFeatures", "(", "valueMap", ",", "Collections", ".", "<", "Integer", ",", "Integer", ">", "emptyMap", "(", ")", ")", ";", "}" ]

[ "Assigns", "value", "to", "all", "unfilled", "feature", "variables", "." ]

[ "public", "int", "getIndex", "(", "String", "methodName", ",", "Class", "...", "paramTypes", ")", "{", "for", "(", "int", "i", "=", "0", ",", "n", "=", "methodNames", ".", "length", ";", "i", "<", "n", ";", "i", "++", ")", "if", "(", "methodNames", "[", "i", "]", ".", "equals", "(", "methodName", ")", "&&", "Arrays", ".", "equals", "(", "paramTypes", ",", "parameterTypes", "[", "i", "]", ")", ")", "return", "i", ";", "throw", "new", "IllegalArgumentException", "(", "\"Unable to find non-private method: \"", "+", "methodName", "+", "\" \"", "+", "Arrays", ".", "toString", "(", "paramTypes", ")", ")", ";", "}" ]

[ "Returns", "the", "index", "of", "the", "first", "method", "with", "the", "specified", "name", "and", "param", "types", "." ]

[ "public", "static", "int", "computeFieldSize", "(", "final", "FieldDescriptorLite", "<", "?", ">", "descriptor", ",", "final", "Object", "value", ")", "{", "WireFormat", ".", "FieldType", "type", "=", "descriptor", ".", "getLiteType", "(", ")", ";", "int", "number", "=", "descriptor", ".", "getNumber", "(", ")", ";", "if", "(", "descriptor", ".", "isRepeated", "(", ")", ")", "{", "if", "(", "descriptor", ".", "isPacked", "(", ")", ")", "{", "int", "dataSize", "=", "0", ";", "for", "(", "final", "Object", "element", ":", "(", "List", "<", "?", ">", ")", "value", ")", "{", "dataSize", "+=", "computeElementSizeNoTag", "(", "type", ",", "element", ")", ";", "}", "return", "dataSize", "+", "CodedOutputStream", ".", "computeTagSize", "(", "number", ")", "+", "CodedOutputStream", ".", "computeRawVarint32Size", "(", "dataSize", ")", ";", "}", "else", "{", "int", "size", "=", "0", ";", "for", "(", "final", "Object", "element", ":", "(", "List", "<", "?", ">", ")", "value", ")", "{", "size", "+=", "computeElementSize", "(", "type", ",", "number", ",", "element", ")", ";", "}", "return", "size", ";", "}", "}", "else", "{", "return", "computeElementSize", "(", "type", ",", "number", ",", "value", ")", ";", "}", "}" ]

[ "Compute", "the", "number", "of", "bytes", "needed", "to", "encode", "a", "particular", "field", "." ]

[ "public", "static", "int", "getMinimumCacheSize", "(", "int", "tileSize", ",", "double", "overdrawFactor", ")", "{", "Dimension", "screenSize", "=", "Toolkit", ".", "getDefaultToolkit", "(", ")", ".", "getScreenSize", "(", ")", ";", "return", "(", "int", ")", "Math", ".", "max", "(", "4", ",", "Math", ".", "round", "(", "(", "2", "+", "screenSize", ".", "getWidth", "(", ")", "*", "overdrawFactor", "/", "tileSize", ")", "*", "(", "2", "+", "screenSize", ".", "getHeight", "(", ")", "*", "overdrawFactor", "/", "tileSize", ")", ")", ")", ";", "}" ]

[ "Compute", "the", "minimum", "cache", "size", "for", "a", "view", "using", "the", "size", "of", "the", "screen", ".", "<p", ">", "Combine", "with", "<code", ">", "FrameBufferController", ".", "setUseSquareFrameBuffer", "(", "false", ")", ";", "<", "/", "code", ">" ]

[ "public", "void", "push", "(", "CmsFlexRequest", "req", ",", "CmsFlexResponse", "res", ")", "{", "m_flexRequestList", ".", "add", "(", "req", ")", ";", "m_flexResponseList", ".", "add", "(", "res", ")", ";", "m_flexContextInfoList", ".", "add", "(", "new", "CmsFlexRequestContextInfo", "(", ")", ")", ";", "updateRequestContextInfo", "(", ")", ";", "}" ]

[ "Adds", "another", "flex", "request", "/", "response", "pair", "to", "the", "stack", ".", "<p", ">" ]

[ "@", "Override", "public", "void", "checkPermission", "(", "Permission", "permission", ",", "AddOnModel", "addon", ")", "throws", "IzouPermissionException", "{", "String", "canonicalName", "=", "permission", ".", "getName", "(", ")", ".", "intern", "(", ")", ".", "toLowerCase", "(", ")", ";", "String", "canonicalAction", "=", "permission", ".", "getActions", "(", ")", ".", "intern", "(", ")", ".", "toLowerCase", "(", ")", ";", "if", "(", "canonicalName", ".", "contains", "(", "\"all files\"", ")", "||", "canonicalAction", ".", "equals", "(", "\"execute\"", ")", ")", "{", "throw", "getException", "(", "permission", ".", "getName", "(", ")", ")", ";", "}", "if", "(", "canonicalAction", ".", "equals", "(", "\"read\"", ")", ")", "{", "fileReadCheck", "(", "canonicalName", ")", ";", "}", "fileWriteCheck", "(", "canonicalName", ",", "addon", ")", ";", "}" ]

[ "Checks", "if", "the", "given", "addOn", "is", "allowed", "to", "access", "the", "requested", "service", "and", "registers", "them", "if", "not", "yet", "registered", "." ]

[ "public", "QueryResult", "printQuery", "(", "Session", "session", ",", "String", "jcrSql2", ")", "throws", "RepositoryException", "{", "return", "printQuery", "(", "session", ",", "jcrSql2", ",", "Query", ".", "JCR_SQL2", ",", "-", "1", ",", "null", ")", ";", "}" ]

[ "Execute", "the", "supplied", "JCR", "-", "SQL2", "query", "and", "if", "printing", "is", "enabled", "print", "out", "the", "results", "." ]

[ "void", "removeConnectionListener", "(", "ConnectionManager", "cm", ",", "ConnectionListener", "cl", ")", "{", "if", "(", "cmToCl", "!=", "null", "&&", "cmToCl", ".", "get", "(", "cm", ")", "!=", "null", ")", "{", "cmToCl", ".", "get", "(", "cm", ")", ".", "remove", "(", "cl", ")", ";", "clToC", ".", "remove", "(", "cl", ")", ";", "}", "}" ]

[ "Remove", "a", "connection", "listener" ]

[ "public", "void", "throwMojoException", "(", "String", "msg", ",", "Throwable", "e", ")", "throws", "MojoExecutionException", "{", "if", "(", "failOnError", ")", "{", "throw", "new", "MojoExecutionException", "(", "msg", ",", "e", ")", ";", "}", "else", "{", "getLog", "(", ")", ".", "error", "(", "msg", ",", "e", ")", ";", "}", "}" ]

[ "If", "failOnError", "is", "enabled", "throws", "a", "MojoExecutionException", ".", "Otherwise", "logs", "the", "exception", "and", "resumes", "execution", "." ]

[ "public", "void", "buildDeprecationInfo", "(", "XMLNode", "node", ",", "Content", "enumConstantsTree", ")", "{", "writer", ".", "addDeprecated", "(", "(", "FieldDoc", ")", "enumConstants", ".", "get", "(", "currentEnumConstantsIndex", ")", ",", "enumConstantsTree", ")", ";", "}" ]

[ "Build", "the", "deprecation", "information", "." ]

[ "public", "TechnologyTagModel", "addTagToFileModel", "(", "FileModel", "fileModel", ",", "String", "tagName", ",", "TechnologyTagLevel", "level", ")", "{", "Traversable", "<", "Vertex", ",", "Vertex", ">", "q", "=", "getGraphContext", "(", ")", ".", "getQuery", "(", "TechnologyTagModel", ".", "class", ")", ".", "traverse", "(", "g", "->", "g", ".", "has", "(", "TechnologyTagModel", ".", "NAME", ",", "tagName", ")", ")", ";", "TechnologyTagModel", "technologyTag", "=", "super", ".", "getUnique", "(", "q", ".", "getRawTraversal", "(", ")", ")", ";", "if", "(", "technologyTag", "==", "null", ")", "{", "technologyTag", "=", "create", "(", ")", ";", "technologyTag", ".", "setName", "(", "tagName", ")", ";", "technologyTag", ".", "setLevel", "(", "level", ")", ";", "}", "if", "(", "level", "==", "TechnologyTagLevel", ".", "IMPORTANT", "&&", "fileModel", "instanceof", "SourceFileModel", ")", "(", "(", "SourceFileModel", ")", "fileModel", ")", ".", "setGenerateSourceReport", "(", "true", ")", ";", "technologyTag", ".", "addFileModel", "(", "fileModel", ")", ";", "return", "technologyTag", ";", "}" ]

[ "Adds", "the", "provided", "tag", "to", "the", "provided", "{" ]

[ "public", "static", "Object", "invokeMethod", "(", "Object", "object", ",", "String", "method", ",", "Object", "arguments", ")", "{", "return", "InvokerHelper", ".", "invokeMethod", "(", "object", ",", "method", ",", "arguments", ")", ";", "}" ]

[ "Provide", "a", "dynamic", "method", "invocation", "method", "which", "can", "be", "overloaded", "in", "classes", "to", "implement", "dynamic", "proxies", "easily", "." ]

[ "private", "void", "createViewForSelectAll", "(", "TableInfo", "tableInfo", ",", "Map", "<", "String", ",", "MapReduce", ">", "views", ")", "{", "MapReduce", "mapr", "=", "new", "MapReduce", "(", ")", ";", "mapr", ".", "setMap", "(", "\"function(doc){if(doc.\"", "+", "tableInfo", ".", "getIdColumnName", "(", ")", "+", "\"){emit(null, doc);}}\"", ")", ";", "views", ".", "put", "(", "\"all\"", ",", "mapr", ")", ";", "}" ]

[ "Creates", "the", "view", "for", "select", "all", "." ]

[ "public", "void", "validatePublicVoidNoArg", "(", "boolean", "isStatic", ",", "List", "<", "Throwable", ">", "errors", ")", "{", "validatePublicVoid", "(", "isStatic", ",", "errors", ")", ";", "if", "(", "method", ".", "getParameterTypes", "(", ")", ".", "length", "!=", "0", ")", "{", "errors", ".", "add", "(", "new", "Exception", "(", "\"Method \"", "+", "method", ".", "getName", "(", ")", "+", "\" should have no parameters\"", ")", ")", ";", "}", "}" ]

[ "Adds", "to", "{" ]

[ "private", "void", "applyInstallExtension", "(", "DefaultInstalledExtension", "installedExtension", ",", "String", "namespace", ",", "boolean", "dependency", ",", "Map", "<", "String", ",", "Object", ">", "properties", ",", "Map", "<", "String", ",", "ExtensionDependency", ">", "managedDependencies", ")", "throws", "InstallException", "{", "// INSTALLED", "installedExtension", ".", "setInstalled", "(", "true", ",", "namespace", ")", ";", "installedExtension", ".", "setInstallDate", "(", "new", "Date", "(", ")", ",", "namespace", ")", ";", "// DEPENDENCY", "installedExtension", ".", "setDependency", "(", "dependency", ",", "namespace", ")", ";", "// Add custom install properties for the specified namespace. The map holding the namespace properties should", "// not be null because it is initialized by the InstalledExtension#setInstalled(true, namespace) call above.", "installedExtension", ".", "getNamespaceProperties", "(", "namespace", ")", ".", "putAll", "(", "properties", ")", ";", "// Save properties", "try", "{", "this", ".", "localRepository", ".", "setProperties", "(", "installedExtension", ".", "getLocalExtension", "(", ")", ",", "installedExtension", ".", "getProperties", "(", ")", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "InstallException", "(", "\"Failed to modify extension descriptor\"", ",", "e", ")", ";", "}", "// VALID", "installedExtension", ".", "setValid", "(", "namespace", ",", "isValid", "(", "installedExtension", ",", "namespace", ",", "managedDependencies", ")", ")", ";", "// Update caches", "addInstalledExtension", "(", "installedExtension", ",", "namespace", ")", ";", "}" ]

[ "Install", "provided", "extension", "." ]

[ "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "public", "void", "setAutoTransferringHeader", "(", "String", "name", ",", "String", "value", ")", "{", "Hashtable", "headers", "=", "getAutoTransferringHeaders", "(", ")", ";", "headers", ".", "put", "(", "name", ",", "value", ")", ";", "// setHeader(name, value);", "}" ]

[ "Set", "a", "header", "that", "should", "be", "automatically", "transferred", "to", "all", "requests", "in", "a", "chain", ".", "These", "headers", "will", "be", "backed", "up", "in", "a", "request", "attribute", "that", "will", "automatically", "read", "and", "transferred", "by", "all", "ChainedResponses", ".", "This", "method", "is", "useful", "for", "transparently", "transferring", "the", "original", "headers", "sent", "by", "the", "client", "without", "forcing", "servlets", "to", "be", "specially", "written", "to", "transfer", "these", "headers", "." ]

[ "public", "static", "MozuUrl", "deleteExtendedPropertyUrl", "(", "String", "key", ",", "String", "orderId", ",", "String", "updateMode", ",", "String", "version", ")", "{", "UrlFormatter", "formatter", "=", "new", "UrlFormatter", "(", "\"/api/commerce/orders/{orderId}/extendedproperties/{key}?updatemode={updateMode}&version={version}\"", ")", ";", "formatter", ".", "formatUrl", "(", "\"key\"", ",", "key", ")", ";", "formatter", ".", "formatUrl", "(", "\"orderId\"", ",", "orderId", ")", ";", "formatter", ".", "formatUrl", "(", "\"updateMode\"", ",", "updateMode", ")", ";", "formatter", ".", "formatUrl", "(", "\"version\"", ",", "version", ")", ";", "return", "new", "MozuUrl", "(", "formatter", ".", "getResourceUrl", "(", ")", ",", "MozuUrl", ".", "UrlLocation", ".", "TENANT_POD", ")", ";", "}" ]

[ "Get", "Resource", "Url", "for", "DeleteExtendedProperty" ]

[ "public", "static", "void", "copyFields", "(", "Connection", "connection", ",", "SimpleResultSet", "rs", ",", "TableLocation", "tableLocation", ")", "throws", "SQLException", "{", "DatabaseMetaData", "meta", "=", "connection", ".", "getMetaData", "(", ")", ";", "ResultSet", "columnsRs", "=", "meta", ".", "getColumns", "(", "tableLocation", ".", "getCatalog", "(", "null", ")", ",", "tableLocation", ".", "getSchema", "(", "null", ")", ",", "tableLocation", ".", "getTable", "(", ")", ",", "null", ")", ";", "Map", "<", "Integer", ",", "Object", "[", "]", ">", "columns", "=", "new", "HashMap", "<", "Integer", ",", "Object", "[", "]", ">", "(", ")", ";", "int", "COLUMN_NAME", "=", "0", ",", "COLUMN_TYPE", "=", "1", ",", "COLUMN_TYPENAME", "=", "2", ",", "COLUMN_PRECISION", "=", "3", ",", "COLUMN_SCALE", "=", "4", ";", "try", "{", "while", "(", "columnsRs", ".", "next", "(", ")", ")", "{", "Object", "[", "]", "columnInfoObjects", "=", "new", "Object", "[", "COLUMN_SCALE", "+", "1", "]", ";", "columnInfoObjects", "[", "COLUMN_NAME", "]", "=", "columnsRs", ".", "getString", "(", "\"COLUMN_NAME\"", ")", ";", "columnInfoObjects", "[", "COLUMN_TYPE", "]", "=", "columnsRs", ".", "getInt", "(", "\"DATA_TYPE\"", ")", ";", "columnInfoObjects", "[", "COLUMN_TYPENAME", "]", "=", "columnsRs", ".", "getString", "(", "\"TYPE_NAME\"", ")", ";", "columnInfoObjects", "[", "COLUMN_PRECISION", "]", "=", "columnsRs", ".", "getInt", "(", "\"COLUMN_SIZE\"", ")", ";", "columnInfoObjects", "[", "COLUMN_SCALE", "]", "=", "columnsRs", ".", "getInt", "(", "\"DECIMAL_DIGITS\"", ")", ";", "columns", ".", "put", "(", "columnsRs", ".", "getInt", "(", "\"ORDINAL_POSITION\"", ")", ",", "columnInfoObjects", ")", ";", "}", "}", "finally", "{", "columnsRs", ".", "close", "(", ")", ";", "}", "for", "(", "int", "i", "=", "1", ";", "i", "<=", "columns", ".", "size", "(", ")", ";", "i", "++", ")", "{", "Object", "[", "]", "columnInfoObjects", "=", "columns", ".", "get", "(", "i", ")", ";", "rs", ".", "addColumn", "(", "(", "String", ")", "columnInfoObjects", "[", "COLUMN_NAME", "]", ",", "(", "Integer", ")", "columnInfoObjects", "[", "COLUMN_TYPE", "]", ",", "(", "String", ")", "columnInfoObjects", "[", "COLUMN_TYPENAME", "]", ",", "(", "Integer", ")", "columnInfoObjects", "[", "COLUMN_PRECISION", "]", ",", "(", "Integer", ")", "columnInfoObjects", "[", "COLUMN_SCALE", "]", ")", ";", "}", "}" ]

[ "Copy", "fields", "from", "table", "into", "a", "{", "@link", "org", ".", "h2", ".", "tools", ".", "SimpleResultSet", "}" ]

[ "long", "getHtindex", "(", "int", "index", ",", "int", "tableid", ")", "{", "if", "(", "tableid", "==", "header", ".", "currentTableId", "(", ")", ")", "{", "return", "htindex", "[", "index", "]", ";", "}", "else", "{", "return", "new_htindex", "[", "index", "]", ";", "}", "}" ]

[ "************************************************************************", "Retrieve", "the", "object", "pointer", "from", "the", "table", ".", "If", "we", "are", "in", "the", "process", "of", "doubling", "this", "method", "finds", "the", "correct", "table", "to", "update", "(", "since", "there", "are", "two", "tables", "active", "during", "the", "doubling", "process", ")", ".", "***********************************************************************" ]

[ "public", "void", "registerExecutor", "(", "String", "appId", ",", "String", "execId", ",", "ExecutorShuffleInfo", "executorInfo", ")", "{", "AppExecId", "fullId", "=", "new", "AppExecId", "(", "appId", ",", "execId", ")", ";", "logger", ".", "info", "(", "\"Registered executor {} with {}\"", ",", "fullId", ",", "executorInfo", ")", ";", "if", "(", "!", "knownManagers", ".", "contains", "(", "executorInfo", ".", "shuffleManager", ")", ")", "{", "throw", "new", "UnsupportedOperationException", "(", "\"Unsupported shuffle manager of executor: \"", "+", "executorInfo", ")", ";", "}", "try", "{", "if", "(", "db", "!=", "null", ")", "{", "byte", "[", "]", "key", "=", "dbAppExecKey", "(", "fullId", ")", ";", "byte", "[", "]", "value", "=", "mapper", ".", "writeValueAsString", "(", "executorInfo", ")", ".", "getBytes", "(", "StandardCharsets", ".", "UTF_8", ")", ";", "db", ".", "put", "(", "key", ",", "value", ")", ";", "}", "}", "catch", "(", "Exception", "e", ")", "{", "logger", ".", "error", "(", "\"Error saving registered executors\"", ",", "e", ")", ";", "}", "executors", ".", "put", "(", "fullId", ",", "executorInfo", ")", ";", "}" ]

[ "Registers", "a", "new", "Executor", "with", "all", "the", "configuration", "we", "need", "to", "find", "its", "shuffle", "files", "." ]

[ "private", "String", "readLockFile", "(", ")", "{", "String", "msg", "=", "null", ";", "try", "(", "RandomAccessFile", "f", "=", "new", "RandomAccessFile", "(", "lockFile", ",", "\"rw\"", ")", ")", "{", "msg", "=", "f", ".", "readLine", "(", ")", ";", "}", "catch", "(", "IOException", "ex", ")", "{", "LOGGER", ".", "debug", "(", "String", ".", "format", "(", "\"Error reading lock file: %s\"", ",", "lockFile", ")", ",", "ex", ")", ";", "}", "return", "msg", ";", "}" ]

[ "Reads", "the", "first", "line", "from", "the", "lock", "file", "and", "returns", "the", "results", "as", "a", "string", "." ]

[ "@", "SuppressWarnings", "(", "{", "\"unchecked\"", ",", "\"rawtypes\"", "}", ")", "protected", "Object", "convertList", "(", "CachingPojoPath", "currentPath", ",", "PojoPathContext", "context", ",", "PojoPathState", "state", ",", "Object", "arrayOrCollection", ")", "{", "Object", "arrayOrList", "=", "arrayOrCollection", ";", "if", "(", "arrayOrCollection", "instanceof", "Collection", ")", "{", "if", "(", "!", "(", "arrayOrCollection", "instanceof", "List", ")", ")", "{", "// non-list collection (e.g. Set) - create Proxy-List", "if", "(", "state", ".", "cachingDisabled", ")", "{", "PojoPathCachingDisabledException", "cachingException", "=", "new", "PojoPathCachingDisabledException", "(", "currentPath", ".", "getPojoPath", "(", ")", ")", ";", "throw", "new", "PojoPathAccessException", "(", "cachingException", ",", "currentPath", ".", "getPojoPath", "(", ")", ",", "arrayOrCollection", ".", "getClass", "(", ")", ")", ";", "}", "String", "collection2ListPath", "=", "currentPath", ".", "getPojoPath", "(", ")", "+", "PATH_SUFFIX_COLLECTION_LIST", ";", "CachingPojoPath", "listPath", "=", "state", ".", "getCachedPath", "(", "collection2ListPath", ")", ";", "if", "(", "listPath", "==", "null", ")", "{", "listPath", "=", "new", "CachingPojoPath", "(", "collection2ListPath", ")", ";", "listPath", ".", "parent", "=", "currentPath", ";", "listPath", ".", "pojo", "=", "new", "CollectionList", "(", "(", "Collection", ")", "arrayOrCollection", ")", ";", "state", ".", "setCachedPath", "(", "collection2ListPath", ",", "listPath", ")", ";", "}", "arrayOrList", "=", "listPath", ".", "pojo", ";", "}", "}", "return", "arrayOrList", ";", "}" ]

[ "This", "method", "converts", "the", "given", "{", "@code", "arrayOrCollection", "}", "to", "a", "{", "@link", "List", "}", "as", "necessary", "." ]

[ "private", "static", "void", "longToByteArray", "(", "long", "l", ",", "byte", "[", "]", "ba", ",", "int", "offset", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "SIZE_OF_LONG", ";", "++", "i", ")", "{", "final", "int", "shift", "=", "i", "<<", "3", ";", "// i * 8", "ba", "[", "offset", "+", "SIZE_OF_LONG", "-", "1", "-", "i", "]", "=", "(", "byte", ")", "(", "(", "l", "&", "(", "0xff", "L", "<<", "shift", ")", ")", ">>>", "shift", ")", ";", "}", "}" ]

[ "Converts", "a", "long", "to", "a", "byte", "array", "." ]

[ "int", "getFieldIndex", "(", "TypeElement", "declaringClass", ",", "String", "name", ",", "TypeMirror", "type", ")", "{", "return", "getFieldIndex", "(", "declaringClass", ",", "name", ",", "Descriptor", ".", "getFieldDesriptor", "(", "type", ")", ")", ";", "}" ]

[ "Returns", "the", "constant", "map", "index", "to", "field" ]

[ "public", "final", "Tenant", "createTenant", "(", "ProjectName", "parent", ",", "Tenant", "tenant", ")", "{", "CreateTenantRequest", "request", "=", "CreateTenantRequest", ".", "newBuilder", "(", ")", ".", "setParent", "(", "parent", "==", "null", "?", "null", ":", "parent", ".", "toString", "(", ")", ")", ".", "setTenant", "(", "tenant", ")", ".", "build", "(", ")", ";", "return", "createTenant", "(", "request", ")", ";", "}" ]

[ "Creates", "a", "new", "tenant", "entity", "." ]

[ "public", "static", "<", "T", "extends", "MethodDescription", ">", "ElementMatcher", ".", "Junction", "<", "T", ">", "takesGenericArgument", "(", "int", "index", ",", "Type", "type", ")", "{", "return", "takesGenericArgument", "(", "index", ",", "TypeDefinition", ".", "Sort", ".", "describe", "(", "type", ")", ")", ";", "}" ]

[ "Matches", "{", "@link", "MethodDescription", "}", "s", "that", "define", "a", "given", "generic", "type", "as", "a", "parameter", "at", "the", "given", "index", "." ]

[ "private", "static", "XPathExpression", "buildExpression", "(", "String", "xPathExpression", ",", "NamespaceContext", "nsContext", ")", "throws", "XPathExpressionException", "{", "XPath", "xpath", "=", "createXPathFactory", "(", ")", ".", "newXPath", "(", ")", ";", "if", "(", "nsContext", "!=", "null", ")", "{", "xpath", ".", "setNamespaceContext", "(", "nsContext", ")", ";", "}", "return", "xpath", ".", "compile", "(", "xPathExpression", ")", ";", "}" ]

[ "Construct", "a", "xPath", "expression", "instance", "with", "given", "expression", "string", "and", "namespace", "context", ".", "If", "namespace", "context", "is", "not", "specified", "a", "default", "context", "is", "built", "from", "the", "XML", "node", "that", "is", "evaluated", "against", "." ]

[ "public", "GetAccountSummaryResult", "withSummaryMap", "(", "java", ".", "util", ".", "Map", "<", "String", ",", "Integer", ">", "summaryMap", ")", "{", "setSummaryMap", "(", "summaryMap", ")", ";", "return", "this", ";", "}" ]

[ "<p", ">", "A", "set", "of", "key–value", "pairs", "containing", "information", "about", "IAM", "entity", "usage", "and", "IAM", "quotas", ".", "<", "/", "p", ">" ]

[ "public", "void", "addImage", "(", "Image", "image", ",", "boolean", "inlineImage", ")", "throws", "DocumentException", "{", "if", "(", "!", "image", ".", "hasAbsoluteY", "(", ")", ")", "throw", "new", "DocumentException", "(", "\"The image must have absolute positioning.\"", ")", ";", "float", "matrix", "[", "]", "=", "image", ".", "matrix", "(", ")", ";", "matrix", "[", "Image", ".", "CX", "]", "=", "image", ".", "getAbsoluteX", "(", ")", "-", "matrix", "[", "Image", ".", "CX", "]", ";", "matrix", "[", "Image", ".", "CY", "]", "=", "image", ".", "getAbsoluteY", "(", ")", "-", "matrix", "[", "Image", ".", "CY", "]", ";", "addImage", "(", "image", ",", "matrix", "[", "0", "]", ",", "matrix", "[", "1", "]", ",", "matrix", "[", "2", "]", ",", "matrix", "[", "3", "]", ",", "matrix", "[", "4", "]", ",", "matrix", "[", "5", "]", ",", "inlineImage", ")", ";", "}" ]

[ "Adds", "an", "<CODE", ">", "Image<", "/", "CODE", ">", "to", "the", "page", ".", "The", "<CODE", ">", "Image<", "/", "CODE", ">", "must", "have", "absolute", "positioning", ".", "The", "image", "can", "be", "placed", "inline", "." ]

[ "protected", "void", "commitChange", "(", "final", "CmsSitemapChange", "change", ",", "final", "Command", "callback", ")", "{", "if", "(", "change", "!=", "null", ")", "{", "// save the sitemap", "CmsRpcAction", "<", "CmsSitemapChange", ">", "saveAction", "=", "new", "CmsRpcAction", "<", "CmsSitemapChange", ">", "(", ")", "{", "/**\n * @see org.opencms.gwt.client.rpc.CmsRpcAction#execute()\n */", "@", "Override", "public", "void", "execute", "(", ")", "{", "start", "(", "0", ",", "true", ")", ";", "getService", "(", ")", ".", "save", "(", "getEntryPoint", "(", ")", ",", "change", ",", "this", ")", ";", "}", "/**\n * @see org.opencms.gwt.client.rpc.CmsRpcAction#onResponse(java.lang.Object)\n */", "@", "Override", "public", "void", "onResponse", "(", "CmsSitemapChange", "result", ")", "{", "stop", "(", "false", ")", ";", "applyChange", "(", "result", ")", ";", "if", "(", "callback", "!=", "null", ")", "{", "callback", ".", "execute", "(", ")", ";", "}", "}", "}", ";", "saveAction", ".", "execute", "(", ")", ";", "}", "}" ]

[ "Adds", "a", "change", "to", "the", "queue", ".", "<p", ">" ]

[ "public", "void", "addPool", "(", "String", "alias", ",", "int", "minSize", ",", "int", "maxSize", ")", "{", "if", "(", "alias", "==", "null", ")", "{", "throw", "new", "NullPointerException", "(", "\"Pool alias cannot be null\"", ")", ";", "}", "if", "(", "poolConfigurations", ".", "containsKey", "(", "alias", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"A pool with the alias '\"", "+", "alias", "+", "\"' is already configured\"", ")", ";", "}", "else", "{", "poolConfigurations", ".", "put", "(", "alias", ",", "new", "PoolConfiguration", "(", "minSize", ",", "maxSize", ")", ")", ";", "}", "}" ]

[ "Adds", "a", "new", "pool", "with", "the", "provided", "minimum", "and", "maximum", "." ]

[ "@", "Override", "public", "void", "registerXAResource", "(", "String", "uniqueName", ",", "XAResource", "xaResource", ")", "{", "Ehcache3XAResourceProducer", "xaResourceProducer", "=", "producers", ".", "get", "(", "uniqueName", ")", ";", "if", "(", "xaResourceProducer", "==", "null", ")", "{", "xaResourceProducer", "=", "new", "Ehcache3XAResourceProducer", "(", ")", ";", "xaResourceProducer", ".", "setUniqueName", "(", "uniqueName", ")", ";", "// the initial xaResource must be added before init() can be called", "xaResourceProducer", ".", "addXAResource", "(", "xaResource", ")", ";", "Ehcache3XAResourceProducer", "previous", "=", "producers", ".", "putIfAbsent", "(", "uniqueName", ",", "xaResourceProducer", ")", ";", "if", "(", "previous", "==", "null", ")", "{", "xaResourceProducer", ".", "init", "(", ")", ";", "}", "else", "{", "previous", ".", "addXAResource", "(", "xaResource", ")", ";", "}", "}", "else", "{", "xaResourceProducer", ".", "addXAResource", "(", "xaResource", ")", ";", "}", "}" ]

[ "Register", "an", "XAResource", "of", "a", "cache", "with", "BTM", ".", "The", "first", "time", "a", "XAResource", "is", "registered", "a", "new", "EhCacheXAResourceProducer", "is", "created", "to", "hold", "it", "." ]

[ "public", "static", "final", "int", "nextInteger", "(", "int", "min", ",", "int", "max", ")", "{", "return", "min", "==", "max", "?", "min", ":", "min", "+", "getRandom", "(", ")", ".", "nextInt", "(", "max", "-", "min", ")", ";", "}" ]

[ "Returns", "a", "random", "value", "in", "the", "desired", "interval" ]

[ "public", "static", "DateLabel", "forDate", "(", "String", "id", ",", "Date", "date", ")", "{", "return", "DateLabel", ".", "forDatePattern", "(", "id", ",", "new", "Model", "<", "Date", ">", "(", "date", ")", ",", "DATE_PATTERN", ")", ";", "}" ]

[ "Creates", "a", "label", "which", "displays", "date", "only", "(", "year", "month", "day", ")", "." ]

[ "static", "boolean", "containsMatch", "(", "String", "actual", ",", "String", "regex", ")", "{", "return", "Pattern", ".", "compile", "(", "regex", ")", ".", "matcher", "(", "actual", ")", ".", "find", "(", ")", ";", "}" ]

[ "Determines", "if", "the", "given", "subject", "contains", "a", "match", "for", "the", "given", "regex", "." ]

[ "public", "Observable", "<", "ApplicationInsightsComponentProactiveDetectionConfigurationInner", ">", "updateAsync", "(", "String", "resourceGroupName", ",", "String", "resourceName", ",", "String", "configurationId", ",", "ApplicationInsightsComponentProactiveDetectionConfigurationInner", "proactiveDetectionProperties", ")", "{", "return", "updateWithServiceResponseAsync", "(", "resourceGroupName", ",", "resourceName", ",", "configurationId", ",", "proactiveDetectionProperties", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "ApplicationInsightsComponentProactiveDetectionConfigurationInner", ">", ",", "ApplicationInsightsComponentProactiveDetectionConfigurationInner", ">", "(", ")", "{", "@", "Override", "public", "ApplicationInsightsComponentProactiveDetectionConfigurationInner", "call", "(", "ServiceResponse", "<", "ApplicationInsightsComponentProactiveDetectionConfigurationInner", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Update", "the", "ProactiveDetection", "configuration", "for", "this", "configuration", "id", "." ]

[ "public", "static", "String", "loadAndGet", "(", "String", "loaderPath", ",", "String", "key", ")", "{", "try", "{", "Properties", "props", "=", "ConfigUtil", ".", "loadProperties", "(", "loaderPath", ")", ";", "return", "props", ".", "getProperty", "(", "key", ")", ";", "}", "catch", "(", "IOException", "ioe", ")", "{", "return", "null", ";", "}", "}" ]

[ "Like", "{", "@link", "#loadAndGet", "(", "File", "String", ")", "}", "but", "obtains", "the", "properties", "data", "via", "the", "classloader", "." ]

[ "public", "Observable", "<", "NetworkInterfaceIPConfigurationInner", ">", "getAsync", "(", "String", "resourceGroupName", ",", "String", "networkInterfaceName", ",", "String", "ipConfigurationName", ")", "{", "return", "getWithServiceResponseAsync", "(", "resourceGroupName", ",", "networkInterfaceName", ",", "ipConfigurationName", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "NetworkInterfaceIPConfigurationInner", ">", ",", "NetworkInterfaceIPConfigurationInner", ">", "(", ")", "{", "@", "Override", "public", "NetworkInterfaceIPConfigurationInner", "call", "(", "ServiceResponse", "<", "NetworkInterfaceIPConfigurationInner", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Gets", "the", "specified", "network", "interface", "ip", "configuration", "." ]

[ "private", "void", "calculateDelays", "(", "int", "k", ",", "double", "[", "]", "cDelays", ",", "double", "[", "]", "[", "]", "net", ")", "{", "double", "t", ";", "int", "ind", ",", "r", "=", "1", ";", "for", "(", "int", "j", "=", "0", ";", "j", "<", "net", ".", "length", ";", "++", "j", ")", "{", "t", "=", "0", ";", "r", "=", "1", ";", "ind", "=", "(", "int", ")", "net", "[", "j", "]", "[", "0", "]", ";", "/*\n * Area k is not included in delays\n */", "while", "(", "networkPipes", "[", "ind", "]", ".", "getIndexPipeWhereDrain", "(", ")", "!=", "k", ")", "{", "ind", "=", "networkPipes", "[", "ind", "]", ".", "getIndexPipeWhereDrain", "(", ")", ";", "t", "+=", "cDelays", "[", "ind", "]", ";", "r", "++", ";", "}", "if", "(", "r", ">", "networkPipes", ".", "length", ")", "{", "pm", ".", "errorMessage", "(", "msg", ".", "message", "(", "\"trentoP.error.incorrectmatrix\"", ")", ")", ";", "throw", "new", "ArithmeticException", "(", "msg", ".", "message", "(", "\"trentoP.error.incorrectmatrix\"", ")", ")", ";", "}", "net", "[", "j", "]", "[", "2", "]", "=", "t", ";", "}", "}" ]

[ "Calcola", "il", "ritardo", "della", "tubazione", "k", "." ]

[ "public", "Iterator", "<", "T", ">", "headIterator", "(", "T", "key", ",", "boolean", "inclusive", ")", "{", "int", "point", "=", "point", "(", "key", ",", "!", "inclusive", ")", ";", "return", "subList", "(", "0", ",", "point", ")", ".", "iterator", "(", ")", ";", "}" ]

[ "Returns", "iterator", "from", "start", "to", "key" ]

[ "@", "Override", "protected", "void", "saxpyi", "(", "long", "N", ",", "double", "alpha", ",", "INDArray", "X", ",", "DataBuffer", "pointers", ",", "INDArray", "Y", ")", "{", "cblas_saxpyi", "(", "(", "int", ")", "N", ",", "(", "float", ")", "alpha", ",", "(", "FloatPointer", ")", "X", ".", "data", "(", ")", ".", "addressPointer", "(", ")", ",", "(", "IntPointer", ")", "pointers", ".", "addressPointer", "(", ")", ",", "(", "FloatPointer", ")", "Y", ".", "data", "(", ")", ".", "addressPointer", "(", ")", ")", ";", "}" ]

[ "Adds", "a", "scalar", "multiple", "of", "float", "compressed", "sparse", "vector", "to", "a", "full", "-", "storage", "vector", "." ]

[ "public", "PutIntegrationResponseResult", "withResponseTemplates", "(", "java", ".", "util", ".", "Map", "<", "String", ",", "String", ">", "responseTemplates", ")", "{", "setResponseTemplates", "(", "responseTemplates", ")", ";", "return", "this", ";", "}" ]

[ "<p", ">", "Specifies", "the", "templates", "used", "to", "transform", "the", "integration", "response", "body", ".", "Response", "templates", "are", "represented", "as", "a", "key", "/", "value", "map", "with", "a", "content", "-", "type", "as", "the", "key", "and", "a", "template", "as", "the", "value", ".", "<", "/", "p", ">" ]

[ "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "public", "<", "A", "extends", "Enum", "<", "A", ">", ">", "EnumPath", "<", "A", ">", "get", "(", "EnumPath", "<", "A", ">", "path", ")", "{", "EnumPath", "<", "A", ">", "newPath", "=", "getEnum", "(", "toString", "(", "path", ")", ",", "(", "Class", "<", "A", ">", ")", "path", ".", "getType", "(", ")", ")", ";", "return", "addMetadataOf", "(", "newPath", ",", "path", ")", ";", "}" ]

[ "Create", "a", "new", "Enum", "path" ]

[ "public", "boolean", "pixelToPlane", "(", "double", "pixelX", ",", "double", "pixelY", ",", "Point2D_F64", "plane", ")", "{", "// computer normalized image coordinates", "pixelToNorm", ".", "compute", "(", "pixelX", ",", "pixelY", ",", "norm", ")", ";", "// Ray pointing from camera center through pixel to ground in ground reference frame", "pointing", ".", "set", "(", "norm", ".", "x", ",", "norm", ".", "y", ",", "1", ")", ";", "GeometryMath_F64", ".", "mult", "(", "cameraToPlane", ".", "getR", "(", ")", ",", "pointing", ",", "pointing", ")", ";", "double", "height", "=", "cameraToPlane", ".", "getY", "(", ")", ";", "// If the point vector and the vector from the plane have the same sign then the ray will not intersect", "// the plane or the intersection is undefined", "if", "(", "pointing", ".", "y", "*", "height", ">=", "0", ")", "return", "false", ";", "// compute the location of the point on the plane in 2D", "double", "t", "=", "-", "height", "/", "pointing", ".", "y", ";", "plane", ".", "x", "=", "pointing", ".", "z", "*", "t", ";", "plane", ".", "y", "=", "-", "pointing", ".", "x", "*", "t", ";", "return", "true", ";", "}" ]

[ "Given", "a", "pixel", "find", "the", "point", "on", "the", "plane", ".", "Be", "sure", "computeInverse", "was", "set", "to", "true", "in", "{", "@link", "#setPlaneToCamera", "(", "georegression", ".", "struct", ".", "se", ".", "Se3_F64", "boolean", ")", "}" ]

[ "public", "CertificateBundle", "mergeCertificate", "(", "String", "vaultBaseUrl", ",", "String", "certificateName", ",", "List", "<", "byte", "[", "]", ">", "x509Certificates", ",", "CertificateAttributes", "certificateAttributes", ",", "Map", "<", "String", ",", "String", ">", "tags", ")", "{", "return", "mergeCertificateWithServiceResponseAsync", "(", "vaultBaseUrl", ",", "certificateName", ",", "x509Certificates", ",", "certificateAttributes", ",", "tags", ")", ".", "toBlocking", "(", ")", ".", "single", "(", ")", ".", "body", "(", ")", ";", "}" ]

[ "Merges", "a", "certificate", "or", "a", "certificate", "chain", "with", "a", "key", "pair", "existing", "on", "the", "server", ".", "The", "MergeCertificate", "operation", "performs", "the", "merging", "of", "a", "certificate", "or", "certificate", "chain", "with", "a", "key", "pair", "currently", "available", "in", "the", "service", ".", "This", "operation", "requires", "the", "certificates", "/", "create", "permission", "." ]

[ "private", "String", "getRealFilePath", "(", "String", "fileName", ",", "BundleHashcodeType", "bundleHashcodeType", ")", "{", "String", "realFilePath", "=", "fileName", ";", "if", "(", "bundleHashcodeType", ".", "equals", "(", "BundleHashcodeType", ".", "INVALID_HASHCODE", ")", ")", "{", "int", "idx", "=", "realFilePath", ".", "indexOf", "(", "JawrConstant", ".", "URL_SEPARATOR", ",", "1", ")", ";", "if", "(", "idx", "!=", "-", "1", ")", "{", "realFilePath", "=", "realFilePath", ".", "substring", "(", "idx", ")", ";", "}", "}", "else", "{", "String", "[", "]", "resourceInfo", "=", "PathNormalizer", ".", "extractBinaryResourceInfo", "(", "realFilePath", ")", ";", "realFilePath", "=", "resourceInfo", "[", "0", "]", ";", "}", "return", "realFilePath", ";", "}" ]

[ "Removes", "the", "cache", "buster" ]

[ "public", "<", "T1", "extends", "Throwable", ",", "T2", "extends", "Throwable", ">", "RuntimeException", "throwIf", "(", "Class", "<", "T1", ">", "t1", ",", "Class", "<", "T2", ">", "t2", ")", "throws", "T1", ",", "T2", "{", "return", "throwIf", "(", "t1", ",", "t2", ",", "NULL_EX", ",", "NULL_EX", ")", ";", "}" ]

[ "Throws", "the", "{" ]

[ "public", "void", "fixupVariables", "(", "java", ".", "util", ".", "Vector", "vars", ",", "int", "globalsSize", ")", "{", "m_mainExp", ".", "fixupVariables", "(", "vars", ",", "globalsSize", ")", ";", "}" ]

[ "This", "function", "is", "used", "to", "fixup", "variables", "from", "QNames", "to", "stack", "frame", "indexes", "at", "stylesheet", "build", "time", "." ]

[ "@", "SneakyThrows", "public", "static", "<", "T", ">", "T", "executeGroovyScript", "(", "final", "GroovyObject", "groovyObject", ",", "final", "String", "methodName", ",", "final", "Object", "[", "]", "args", ",", "final", "Class", "<", "T", ">", "clazz", ",", "final", "boolean", "failOnError", ")", "{", "try", "{", "LOGGER", ".", "trace", "(", "\"Executing groovy script's [{}] method, with parameters [{}]\"", ",", "methodName", ",", "args", ")", ";", "val", "result", "=", "groovyObject", ".", "invokeMethod", "(", "methodName", ",", "args", ")", ";", "LOGGER", ".", "trace", "(", "\"Results returned by the groovy script are [{}]\"", ",", "result", ")", ";", "if", "(", "!", "clazz", ".", "equals", "(", "Void", ".", "class", ")", ")", "{", "return", "getGroovyScriptExecutionResultOrThrow", "(", "clazz", ",", "result", ")", ";", "}", "}", "catch", "(", "final", "Exception", "e", ")", "{", "var", "cause", "=", "(", "Throwable", ")", "null", ";", "if", "(", "e", "instanceof", "InvokerInvocationException", ")", "{", "cause", "=", "e", ".", "getCause", "(", ")", ";", "}", "else", "{", "cause", "=", "e", ";", "}", "if", "(", "failOnError", ")", "{", "throw", "cause", ";", "}", "LOGGER", ".", "error", "(", "cause", ".", "getMessage", "(", ")", ",", "cause", ")", ";", "}", "return", "null", ";", "}" ]

[ "Execute", "groovy", "script", "t", "." ]

[ "public", "void", "addAuxiliarySource", "(", "DObject", "source", ",", "String", "localtype", ")", "{", "source", ".", "addListener", "(", "this", ")", ";", "_auxes", ".", "put", "(", "source", ".", "getOid", "(", ")", ",", "localtype", ")", ";", "}" ]

[ "Adds", "an", "additional", "object", "via", "which", "chat", "messages", "may", "arrive", ".", "The", "chat", "director", "assumes", "the", "caller", "will", "be", "managing", "the", "subscription", "to", "this", "object", "and", "will", "remain", "subscribed", "to", "it", "for", "as", "long", "as", "it", "remains", "in", "effect", "as", "an", "auxiliary", "chat", "source", "." ]

[ "public", "void", "releaseManagedChannel", "(", "ChannelKey", "channelKey", ",", "long", "shutdownTimeoutMs", ")", "{", "boolean", "shutdownManagedChannel", ";", "try", "(", "LockResource", "lockShared", "=", "new", "LockResource", "(", "mLock", ".", "readLock", "(", ")", ")", ")", "{", "Verify", ".", "verify", "(", "mChannels", ".", "containsKey", "(", "channelKey", ")", ")", ";", "ManagedChannelReference", "channelRef", "=", "mChannels", ".", "get", "(", "channelKey", ")", ";", "channelRef", ".", "dereference", "(", ")", ";", "shutdownManagedChannel", "=", "channelRef", ".", "getRefCount", "(", ")", "<=", "0", ";", "LOG", ".", "debug", "(", "\"Released managed channel for: {}. Ref-count: {}\"", ",", "channelKey", ",", "channelRef", ".", "getRefCount", "(", ")", ")", ";", "}", "if", "(", "shutdownManagedChannel", ")", "{", "try", "(", "LockResource", "lockExclusive", "=", "new", "LockResource", "(", "mLock", ".", "writeLock", "(", ")", ")", ")", "{", "if", "(", "mChannels", ".", "containsKey", "(", "channelKey", ")", ")", "{", "ManagedChannelReference", "channelRef", "=", "mChannels", ".", "get", "(", "channelKey", ")", ";", "if", "(", "channelRef", ".", "getRefCount", "(", ")", "<=", "0", ")", "{", "shutdownManagedChannel", "(", "channelKey", ",", "shutdownTimeoutMs", ")", ";", "}", "}", "}", "}", "}" ]

[ "Decreases", "the", "ref", "-", "count", "of", "the", "{", "@link", "ManagedChannel", "}", "for", "the", "given", "address", "." ]

[ "public", "static", "Related", "asTargetWith", "(", "CanonicalPath", "entityPath", ",", "String", "relationship", ")", "{", "return", "new", "Related", "(", "entityPath", ",", "relationship", ",", "EntityRole", ".", "TARGET", ")", ";", "}" ]

[ "Specifies", "a", "filter", "for", "entities", "that", "are", "targets", "of", "a", "relationship", "with", "the", "specified", "entity", "." ]

[ "public", "static", "void", "appendElement", "(", "Element", "parent", ",", "Element", "child", ")", "{", "Node", "tmp", "=", "parent", ".", "getOwnerDocument", "(", ")", ".", "importNode", "(", "child", ",", "true", ")", ";", "parent", ".", "appendChild", "(", "tmp", ")", ";", "}" ]

[ "Appends", "another", "element", "as", "a", "child", "element", "." ]

[ "public", "ActiveMQQueueJmxStats", "addCounts", "(", "ActiveMQQueueJmxStats", "other", ",", "String", "resultBrokerName", ")", "{", "ActiveMQQueueJmxStats", "result", "=", "new", "ActiveMQQueueJmxStats", "(", "resultBrokerName", ",", "this", ".", "queueName", ")", ";", "result", ".", "setCursorPercentUsage", "(", "this", ".", "getCursorPercentUsage", "(", ")", ")", ";", "result", ".", "setDequeueCount", "(", "this", ".", "getDequeueCount", "(", ")", "+", "other", ".", "getDequeueCount", "(", ")", ")", ";", "result", ".", "setEnqueueCount", "(", "this", ".", "getEnqueueCount", "(", ")", "+", "other", ".", "getEnqueueCount", "(", ")", ")", ";", "result", ".", "setMemoryPercentUsage", "(", "this", ".", "getMemoryPercentUsage", "(", ")", ")", ";", "result", ".", "setNumConsumers", "(", "this", ".", "getNumConsumers", "(", ")", "+", "other", ".", "getNumConsumers", "(", ")", ")", ";", "result", ".", "setNumProducers", "(", "this", ".", "getNumProducers", "(", ")", "+", "other", ".", "getNumProducers", "(", ")", ")", ";", "result", ".", "setQueueSize", "(", "this", ".", "getQueueSize", "(", ")", "+", "other", ".", "getQueueSize", "(", ")", ")", ";", "result", ".", "setInflightCount", "(", "this", ".", "getInflightCount", "(", ")", "+", "other", ".", "getInflightCount", "(", ")", ")", ";", "return", "result", ";", "}" ]

[ "Return", "a", "new", "queue", "stats", "structure", "with", "the", "total", "of", "the", "stats", "from", "this", "structure", "and", "the", "one", "given", ".", "Returning", "a", "new", "structure", "keeps", "all", "three", "structures", "unchanged", "in", "the", "manner", "of", "immutability", "to", "make", "it", "easier", "to", "have", "safe", "usage", "under", "concurrency", ".", "Note", "that", "non", "-", "count", "values", "are", "copied", "out", "from", "this", "instance", ";", "those", "values", "from", "the", "given", "other", "stats", "are", "ignored", "." ]

[ "protected", "boolean", "isSupported", "(", "ProfileRequestContext", "<", "?", ",", "?", ">", "context", ",", "String", "uri", ",", "List", "<", "String", ">", "assuranceURIs", ")", "{", "return", "assuranceURIs", ".", "contains", "(", "uri", ")", ";", "}" ]

[ "A", "Proxy", "-", "IdP", "may", "communicate", "with", "an", "IdP", "that", "uses", "different", "URI", "declarations", "for", "the", "same", "type", "of", "authentication", "methods", "e", ".", "g", ".", "the", "Swedish", "eID", "framework", "and", "eIDAS", "has", "different", "URI", ":", "s", "for", "the", "same", "type", "of", "authentication", ".", "This", "method", "will", "enable", "tranformation", "of", "URI", ":", "s", "and", "provide", "the", "possibility", "to", "match", "URI", ":", "s", "from", "different", "schemes", ".", "<p", ">", "The", "default", "implementation", "just", "checks", "if", "the", "supplied", "{", "@code", "uri", "}", "is", "part", "of", "the", "{", "@code", "assuranceURIs", "}", "list", ".", "To", "implement", "different", "behaviour", "override", "this", "method", ".", "<", "/", "p", ">" ]

[ "public", "static", "boolean", "hasWindowsDrive", "(", "String", "path", ",", "boolean", "slashed", ")", "{", "int", "start", "=", "slashed", "?", "1", ":", "0", ";", "return", "path", ".", "length", "(", ")", ">=", "start", "+", "2", "&&", "(", "!", "slashed", "||", "path", ".", "charAt", "(", "0", ")", "==", "'", "'", ")", "&&", "path", ".", "charAt", "(", "start", "+", "1", ")", "==", "'", "'", "&&", "(", "(", "path", ".", "charAt", "(", "start", ")", ">=", "'", "'", "&&", "path", ".", "charAt", "(", "start", ")", "<=", "'", "'", ")", "||", "(", "path", ".", "charAt", "(", "start", ")", ">=", "'", "'", "&&", "path", ".", "charAt", "(", "start", ")", "<=", "'", "'", ")", ")", ";", "}" ]

[ "Checks", "if", "the", "path", "is", "a", "windows", "path", ".", "This", "should", "be", "platform", "independent", "." ]

[ "public", "void", "setIdentity", "(", "String", "name", ",", "String", "email", ")", "{", "if", "(", "GitTaskUtils", ".", "isNullOrBlankString", "(", "name", ")", "||", "GitTaskUtils", ".", "isNullOrBlankString", "(", "email", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Both the username and password must be provided.\"", ")", ";", "}", "identity", "=", "new", "PersonIdent", "(", "name", ",", "email", ")", ";", "}" ]

[ "Sets", "the", "name", "and", "email", "for", "the", "Git", "commands", "user" ]

[ "private", "static", "boolean", "violatesCardinality", "(", "final", "Graph", "graph", ",", "final", "IRI", "model", ")", "{", "final", "boolean", "isIndirect", "=", "LDP", ".", "IndirectContainer", ".", "equals", "(", "model", ")", ";", "return", "isIndirect", "&&", "(", "!", "graph", ".", "contains", "(", "null", ",", "LDP", ".", "insertedContentRelation", ",", "null", ")", "||", "!", "hasMembershipProps", "(", "graph", ")", ")", "||", "!", "isIndirect", "&&", "LDP", ".", "DirectContainer", ".", "equals", "(", "model", ")", "&&", "!", "hasMembershipProps", "(", "graph", ")", "||", "propertiesWithUriRange", ".", "stream", "(", ")", ".", "anyMatch", "(", "p", "->", "graph", ".", "stream", "(", "null", ",", "p", ",", "null", ")", ".", "count", "(", ")", ">", "1", ")", ";", "}" ]

[ "Verify", "that", "the", "cardinality", "of", "the", "propertiesWithUriRange", "properties", ".", "Keep", "any", "whose", "cardinality", "is", ">", "1" ]

[ "public", "void", "serviceName_ipCanBeMovedTo_GET", "(", "String", "serviceName", ",", "String", "ip", ")", "throws", "IOException", "{", "String", "qPath", "=", "\"/dedicated/server/{serviceName}/ipCanBeMovedTo\"", ";", "StringBuilder", "sb", "=", "path", "(", "qPath", ",", "serviceName", ")", ";", "query", "(", "sb", ",", "\"ip\"", ",", "ip", ")", ";", "exec", "(", "qPath", ",", "\"GET\"", ",", "sb", ".", "toString", "(", ")", ",", "null", ")", ";", "}" ]

[ "Check", "if", "given", "IP", "can", "be", "moved", "to", "this", "server" ]

[ "public", "com", ".", "squareup", ".", "okhttp", ".", "Call", "optionsPostAsync", "(", "OptionsPost", "body", ",", "final", "ApiCallback", "<", "OptionsPostResponseStatusSuccess", ">", "callback", ")", "throws", "ApiException", "{", "ProgressResponseBody", ".", "ProgressListener", "progressListener", "=", "null", ";", "ProgressRequestBody", ".", "ProgressRequestListener", "progressRequestListener", "=", "null", ";", "if", "(", "callback", "!=", "null", ")", "{", "progressListener", "=", "new", "ProgressResponseBody", ".", "ProgressListener", "(", ")", "{", "@", "Override", "public", "void", "update", "(", "long", "bytesRead", ",", "long", "contentLength", ",", "boolean", "done", ")", "{", "callback", ".", "onDownloadProgress", "(", "bytesRead", ",", "contentLength", ",", "done", ")", ";", "}", "}", ";", "progressRequestListener", "=", "new", "ProgressRequestBody", ".", "ProgressRequestListener", "(", ")", "{", "@", "Override", "public", "void", "onRequestProgress", "(", "long", "bytesWritten", ",", "long", "contentLength", ",", "boolean", "done", ")", "{", "callback", ".", "onUploadProgress", "(", "bytesWritten", ",", "contentLength", ",", "done", ")", ";", "}", "}", ";", "}", "com", ".", "squareup", ".", "okhttp", ".", "Call", "call", "=", "optionsPostValidateBeforeCall", "(", "body", ",", "progressListener", ",", "progressRequestListener", ")", ";", "Type", "localVarReturnType", "=", "new", "TypeToken", "<", "OptionsPostResponseStatusSuccess", ">", "(", ")", "{", "}", ".", "getType", "(", ")", ";", "apiClient", ".", "executeAsync", "(", "call", ",", "localVarReturnType", ",", "callback", ")", ";", "return", "call", ";", "}" ]

[ "Replace", "old", "options", "with", "new", ".", "(", "asynchronously", ")", "The", "POST", "operation", "will", "replace", "CloudCluster", "/", "Options", "with", "new", "values" ]