Datasets:

---

stojchet

/

base_prediction_dataset

like 0

[ "public", "static", "String", "substringLastFrontIgnoreCase", "(", "String", "str", ",", "String", "...", "delimiters", ")", "{", "assertStringNotNull", "(", "str", ")", ";", "return", "doSubstringFirstRear", "(", "true", ",", "false", ",", "true", ",", "str", ",", "delimiters", ")", ";", "}" ]

[ "Extract", "front", "sub", "-", "string", "from", "last", "-", "found", "delimiter", "ignoring", "case", ".", "<pre", ">", "substringLastFront", "(", "foo", ".", "bar", "/", "baz", ".", "qux", "A", "U", ")", "returns", "foo", ".", "bar", "/", "baz", ".", "q", "<", "/", "pre", ">" ]

[ "@", "Override", "public", "String", "getStorageDir", "(", "DataSegment", "segment", ",", "boolean", "useUniquePath", ")", "{", "// This is only called by HdfsDataSegmentPusher.push(), which will always set useUniquePath to false since any", "// 'uniqueness' will be applied not to the directory but to the filename along with the shard number. This is done", "// to avoid performance issues due to excessive HDFS directories. Hence useUniquePath is ignored here and we", "// expect it to be false.", "Preconditions", ".", "checkArgument", "(", "!", "useUniquePath", ",", "\"useUniquePath must be false for HdfsDataSegmentPusher.getStorageDir()\"", ")", ";", "return", "JOINER", ".", "join", "(", "segment", ".", "getDataSource", "(", ")", ",", "StringUtils", ".", "format", "(", "\"%s_%s\"", ",", "segment", ".", "getInterval", "(", ")", ".", "getStart", "(", ")", ".", "toString", "(", "ISODateTimeFormat", ".", "basicDateTime", "(", ")", ")", ",", "segment", ".", "getInterval", "(", ")", ".", "getEnd", "(", ")", ".", "toString", "(", "ISODateTimeFormat", ".", "basicDateTime", "(", ")", ")", ")", ",", "segment", ".", "getVersion", "(", ")", ".", "replace", "(", "'", "'", ",", "'", "'", ")", ")", ";", "}" ]

[ "Due", "to", "https", ":", "//", "issues", ".", "apache", ".", "org", "/", "jira", "/", "browse", "/", "HDFS", "-", "13", ":", "are", "not", "allowed", "in", "path", "names", ".", "So", "we", "format", "paths", "differently", "for", "HDFS", "." ]

[ "public", "void", "deleteFromTask", "(", "String", "jobId", ",", "String", "taskId", ",", "String", "filePath", ",", "Boolean", "recursive", ",", "FileDeleteFromTaskOptions", "fileDeleteFromTaskOptions", ")", "{", "deleteFromTaskWithServiceResponseAsync", "(", "jobId", ",", "taskId", ",", "filePath", ",", "recursive", ",", "fileDeleteFromTaskOptions", ")", ".", "toBlocking", "(", ")", ".", "single", "(", ")", ".", "body", "(", ")", ";", "}" ]

[ "Deletes", "the", "specified", "task", "file", "from", "the", "compute", "node", "where", "the", "task", "ran", "." ]

[ "public", "Signature", "argName", "(", "int", "index", ",", "String", "name", ")", "{", "String", "[", "]", "argNames", "=", "Arrays", ".", "copyOf", "(", "argNames", "(", ")", ",", "argNames", "(", ")", ".", "length", ")", ";", "argNames", "[", "index", "]", "=", "name", ";", "return", "new", "Signature", "(", "type", "(", ")", ",", "argNames", ")", ";", "}" ]

[ "Set", "the", "argument", "name", "at", "the", "given", "index", "." ]

[ "public", "static", "int", "countIgnoreCase", "(", "final", "String", "source", ",", "final", "String", "target", ")", "{", "if", "(", "isEmpty", "(", "source", ")", "||", "isEmpty", "(", "target", ")", ")", "{", "return", "0", ";", "}", "return", "count", "(", "source", ".", "toLowerCase", "(", ")", ",", "target", ".", "toLowerCase", "(", ")", ")", ";", "}" ]

[ "Count", "how", "much", "target", "in", "souce", "string", ".", "<", "/", "br", ">", "统计target在source中出现的次数。" ]

[ "public", "void", "insertTable", "(", "Table", "aTable", ",", "Point", "aLocation", ")", "{", "if", "(", "aTable", "==", "null", ")", "{", "throw", "new", "NullPointerException", "(", "\"insertTable - table has null-value\"", ")", ";", "}", "if", "(", "aLocation", "==", "null", ")", "{", "throw", "new", "NullPointerException", "(", "\"insertTable - point has null-value\"", ")", ";", "}", "mTableInserted", "=", "true", ";", "aTable", ".", "complete", "(", ")", ";", "if", "(", "aLocation", ".", "y", ">", "columns", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"insertTable -- wrong columnposition(\"", "+", "aLocation", ".", "y", "+", "\") of location; max =\"", "+", "columns", ")", ";", "}", "int", "rowCount", "=", "aLocation", ".", "x", "+", "1", "-", "rows", ".", "size", "(", ")", ";", "int", "i", "=", "0", ";", "if", "(", "rowCount", ">", "0", ")", "{", "//create new rows ?", "for", "(", ";", "i", "<", "rowCount", ";", "i", "++", ")", "{", "rows", ".", "add", "(", "new", "Row", "(", "columns", ")", ")", ";", "}", "}", "rows", ".", "get", "(", "aLocation", ".", "x", ")", ".", "setElement", "(", "aTable", ",", "aLocation", ".", "y", ")", ";", "setCurrentLocationToNextValidPosition", "(", "aLocation", ")", ";", "}" ]

[ "To", "put", "a", "table", "within", "the", "existing", "table", "at", "the", "given", "position", "generateTable", "will", "of", "course", "re", "-", "arrange", "the", "widths", "of", "the", "columns", "." ]

[ "public", "static", "WebElement", "findElement", "(", "Page", "page", ",", "String", "code", ",", "Object", "...", "args", ")", "{", "return", "Context", ".", "getDriver", "(", ")", ".", "findElement", "(", "getLocator", "(", "page", ".", "getApplication", "(", ")", ",", "page", ".", "getPageKey", "(", ")", "+", "code", ",", "args", ")", ")", ";", "}" ]

[ "Find", "the", "first", "{", "@link", "WebElement", "}", "using", "the", "given", "method", ".", "This", "method", "is", "affected", "by", "the", "implicit", "wait", "times", "in", "force", "at", "the", "time", "of", "execution", ".", "The", "findElement", "(", "..", ")", "invocation", "will", "return", "a", "matching", "row", "or", "try", "again", "repeatedly", "until", "the", "configured", "timeout", "is", "reached", "." ]

[ "public", "final", "double", "getDouble", "(", "String", "attribute", ",", "String", "...", "path", ")", "{", "try", "{", "return", "Double", ".", "parseDouble", "(", "getNodeString", "(", "attribute", ",", "path", ")", ")", ";", "}", "catch", "(", "final", "NumberFormatException", "exception", ")", "{", "throw", "new", "LionEngineException", "(", "exception", ",", "media", ")", ";", "}", "}" ]

[ "Get", "a", "double", "in", "the", "xml", "tree", "." ]

[ "public", "static", "UnsupportedCycOperationException", "fromThrowable", "(", "String", "message", ",", "Throwable", "cause", ")", "{", "return", "(", "cause", "instanceof", "UnsupportedCycOperationException", "&&", "Objects", ".", "equals", "(", "message", ",", "cause", ".", "getMessage", "(", ")", ")", ")", "?", "(", "UnsupportedCycOperationException", ")", "cause", ":", "new", "UnsupportedCycOperationException", "(", "message", ",", "cause", ")", ";", "}" ]

[ "Converts", "a", "Throwable", "to", "a", "UnsupportedCycOperationException", "with", "the", "specified", "detail", "message", ".", "If", "the", "Throwable", "is", "a", "UnsupportedCycOperationException", "and", "if", "the", "Throwable", "s", "message", "is", "identical", "to", "the", "one", "supplied", "the", "Throwable", "will", "be", "passed", "through", "unmodified", ";", "otherwise", "it", "will", "be", "wrapped", "in", "a", "new", "UnsupportedCycOperationException", "with", "the", "detail", "message", "." ]

[ "public", "void", "sendData", "(", "byte", "[", "]", "data", ")", "throws", "ResponseException", "{", "if", "(", "con", ".", "isClosed", "(", ")", ")", "return", ";", "Socket", "socket", "=", "null", ";", "try", "{", "socket", "=", "conHandler", ".", "createDataSocket", "(", ")", ";", "dataConnections", ".", "add", "(", "socket", ")", ";", "OutputStream", "out", "=", "socket", ".", "getOutputStream", "(", ")", ";", "Utils", ".", "write", "(", "out", ",", "data", ",", "data", ".", "length", ",", "conHandler", ".", "isAsciiMode", "(", ")", ")", ";", "bytesTransferred", "+=", "data", ".", "length", ";", "out", ".", "flush", "(", ")", ";", "Utils", ".", "closeQuietly", "(", "out", ")", ";", "Utils", ".", "closeQuietly", "(", "socket", ")", ";", "}", "catch", "(", "SocketException", "ex", ")", "{", "throw", "new", "ResponseException", "(", "426", ",", "\"Transfer aborted\"", ")", ";", "}", "catch", "(", "IOException", "ex", ")", "{", "throw", "new", "ResponseException", "(", "425", ",", "\"An error occurred while transferring the data\"", ")", ";", "}", "finally", "{", "onUpdate", "(", ")", ";", "if", "(", "socket", "!=", "null", ")", "dataConnections", ".", "remove", "(", "socket", ")", ";", "}", "}" ]

[ "Sends", "an", "array", "of", "bytes", "through", "a", "data", "connection" ]

[ "protected", "void", "onFileChoose", "(", "JFileChooser", "fileChooser", ",", "ActionEvent", "actionEvent", ")", "{", "final", "int", "returnVal", "=", "fileChooser", ".", "showOpenDialog", "(", "parent", ")", ";", "if", "(", "returnVal", "==", "JFileChooser", ".", "APPROVE_OPTION", ")", "{", "final", "File", "file", "=", "fileChooser", ".", "getSelectedFile", "(", ")", ";", "onApproveOption", "(", "file", ",", "actionEvent", ")", ";", "}", "else", "{", "onCancel", "(", "actionEvent", ")", ";", "}", "}" ]

[ "Callback", "method", "to", "interact", "on", "file", "choose", "." ]

[ "public", "static", "String", "map2URLEncoded", "(", "Map", "params", ")", "{", "StringBuilder", "stringBuilder", "=", "new", "StringBuilder", "(", ")", ";", "try", "{", "Set", "keySet", "=", "params", ".", "keySet", "(", ")", ";", "Object", "[", "]", "keys", "=", "keySet", ".", "toArray", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "keys", ".", "length", ";", "i", "++", ")", "{", "stringBuilder", ".", "append", "(", "encode", "(", "keys", "[", "i", "]", ".", "toString", "(", ")", ",", "\"UTF-8\"", ")", ")", ".", "append", "(", "\"=\"", ")", ".", "append", "(", "encode", "(", "params", ".", "get", "(", "keys", "[", "i", "]", ")", ".", "toString", "(", ")", ",", "\"UTF-8\"", ")", ")", ";", "if", "(", "i", "<", "(", "keys", ".", "length", "-", "1", ")", ")", "{", "stringBuilder", ".", "append", "(", "\"&\"", ")", ";", "}", "}", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "HttpException", "(", "\"failed to generate content from map\"", ",", "e", ")", ";", "}", "return", "stringBuilder", ".", "toString", "(", ")", ";", "}" ]

[ "Converts", "a", "map", "to", "URL", "-", "encoded", "string", ".", "This", "is", "a", "convenience", "method", "which", "can", "be", "used", "in", "combination", "with", "{", "@link", "#post", "(", "String", "byte", "[]", ")", "}", "{", "@link", "#put", "(", "String", "String", ")", "}", "and", "others", ".", "It", "makes", "it", "easy", "to", "convert", "parameters", "to", "submit", "a", "string", ":" ]

[ "@", "Override", "public", "final", "boolean", "isValid", "(", "final", "Object", "pvalue", ",", "final", "ConstraintValidatorContext", "pcontext", ")", "{", "String", "valueAsString", "=", "Objects", ".", "toString", "(", "pvalue", ",", "StringUtils", ".", "EMPTY", ")", ";", "if", "(", "StringUtils", ".", "isEmpty", "(", "valueAsString", ")", ")", "{", "return", "true", ";", "}", "if", "(", "ignoreWhiteSpaces", ")", "{", "valueAsString", "=", "valueAsString", ".", "replaceAll", "(", "\"\\\\s\"", ",", "StringUtils", ".", "EMPTY", ")", ";", "}", "if", "(", "ignoreMinus", ")", "{", "valueAsString", "=", "valueAsString", ".", "replaceAll", "(", "\"-\"", ",", "StringUtils", ".", "EMPTY", ")", ";", "}", "if", "(", "ignoreSlashes", ")", "{", "valueAsString", "=", "valueAsString", ".", "replaceAll", "(", "\"/\"", ",", "StringUtils", ".", "EMPTY", ")", ";", "}", "return", "StringUtils", ".", "length", "(", "valueAsString", ")", "==", "size1", "||", "StringUtils", ".", "length", "(", "valueAsString", ")", "==", "size2", ";", "}" ]

[ "{", "@inheritDoc", "}", "check", "if", "given", "object", "is", "valid", "." ]

[ "public", "static", "ComputationGraph", "restoreComputationGraph", "(", "@", "NonNull", "InputStream", "is", ",", "boolean", "loadUpdater", ")", "throws", "IOException", "{", "checkInputStream", "(", "is", ")", ";", "File", "tmpFile", "=", "null", ";", "try", "{", "tmpFile", "=", "tempFileFromStream", "(", "is", ")", ";", "return", "restoreComputationGraph", "(", "tmpFile", ",", "loadUpdater", ")", ";", "}", "finally", "{", "if", "(", "tmpFile", "!=", "null", ")", "{", "tmpFile", ".", "delete", "(", ")", ";", "}", "}", "}" ]

[ "Load", "a", "computation", "graph", "from", "a", "InputStream", "@param", "is", "the", "inputstream", "to", "get", "the", "computation", "graph", "from", "@return", "the", "loaded", "computation", "graph" ]

[ "public", "static", "UnitResponse", "createTimeout", "(", "Object", "dataOrException", ",", "String", "errMsg", ")", "{", "return", "new", "UnitResponse", "(", ")", ".", "setCode", "(", "Group", ".", "CODE_TIME_OUT", ")", ".", "setData", "(", "dataOrException", ")", ".", "setMessage", "(", "errMsg", ")", ";", "}" ]

[ "create", "a", "new", "timed", "out", "unit", "response", "." ]

[ "private", "GenericMatchInfo", "createGenericMatchInfo", "(", "MatchInfo", "matchInfo", ")", "{", "GenericNameType", "nameType", "=", "null", ";", "TimeType", "timeType", "=", "TimeType", ".", "UNKNOWN", ";", "switch", "(", "matchInfo", ".", "nameType", "(", ")", ")", "{", "case", "LONG_STANDARD", ":", "nameType", "=", "GenericNameType", ".", "LONG", ";", "timeType", "=", "TimeType", ".", "STANDARD", ";", "break", ";", "case", "LONG_GENERIC", ":", "nameType", "=", "GenericNameType", ".", "LONG", ";", "break", ";", "case", "SHORT_STANDARD", ":", "nameType", "=", "GenericNameType", ".", "SHORT", ";", "timeType", "=", "TimeType", ".", "STANDARD", ";", "break", ";", "case", "SHORT_GENERIC", ":", "nameType", "=", "GenericNameType", ".", "SHORT", ";", "break", ";", "default", ":", "throw", "new", "IllegalArgumentException", "(", "\"Unexpected MatchInfo name type - \"", "+", "matchInfo", ".", "nameType", "(", ")", ")", ";", "}", "String", "tzID", "=", "matchInfo", ".", "tzID", "(", ")", ";", "if", "(", "tzID", "==", "null", ")", "{", "String", "mzID", "=", "matchInfo", ".", "mzID", "(", ")", ";", "assert", "(", "mzID", "!=", "null", ")", ";", "tzID", "=", "_tznames", ".", "getReferenceZoneID", "(", "mzID", ",", "getTargetRegion", "(", ")", ")", ";", "}", "assert", "(", "tzID", "!=", "null", ")", ";", "GenericMatchInfo", "gmatch", "=", "new", "GenericMatchInfo", "(", "nameType", ",", "tzID", ",", "matchInfo", ".", "matchLength", "(", ")", ",", "timeType", ")", ";", "return", "gmatch", ";", "}" ]

[ "Returns", "a", "<code", ">", "GenericMatchInfo<", "/", "code", ">", "for", "the", "given", "<code", ">", "MatchInfo<", "/", "code", ">", "." ]

[ "public", "static", "double", "dotProduct", "(", "Node", "[", "]", "n1", ",", "Node", "[", "]", "n2", ")", "{", "// logger.info(\"n1 \" + n1.length);", "// logger.info(\"n2 \" + n2.length);", "double", "sum", "=", "0", ";", "int", "i", "=", "0", ",", "j", "=", "0", ";", "while", "(", "i", "<", "n1", ".", "length", "&&", "j", "<", "n2", ".", "length", ")", "{", "if", "(", "n1", "[", "i", "]", "==", "null", ")", "break", ";", "// logger.error(\"n1\" + n1[i] + \" \" + i);", "if", "(", "n2", "[", "j", "]", "==", "null", ")", "break", ";", "// logger.error(\"n2\" + n2[j] + \" \" + j);", "// logger.info(n1[i].index + \" == \" + n2[j].index);", "if", "(", "n1", "[", "i", "]", ".", "index", "==", "n2", "[", "j", "]", ".", "index", ")", "{", "// logger.info(n1[i].index + \" == \" + n2[j].index);", "sum", "+=", "n1", "[", "i", "]", ".", "value", "*", "n2", "[", "j", "]", ".", "value", ";", "++", "i", ";", "++", "j", ";", "}", "else", "{", "if", "(", "n1", "[", "i", "]", ".", "index", ">", "n2", "[", "j", "]", ".", "index", ")", "{", "// logger.info(n1[i].index + \" > \" + n2[j].index);", "++", "j", ";", "}", "else", "{", "// logger.info(n1[i].index + \" <= \" + n2[j].index);", "++", "i", ";", "}", "}", "}", "return", "sum", ";", "}" ]

[ "Returns", "an", "iterator", "over", "the", "elements", "in", "this", "vector", "in", "proper", "sequence", "(", "optional", "operation", ")", "." ]

[ "public", "static", "void", "insert", "(", "String", "key", ",", "String", "[", "]", "words", ")", "{", "SmartForest", "<", "List", "<", "String", ">>", "synonyms", "=", "get", "(", "key", ")", ";", "List", "<", "String", ">", "list", "=", "new", "ArrayList", "<>", "(", ")", ";", "for", "(", "String", "word", ":", "words", ")", "{", "if", "(", "StringUtil", ".", "isBlank", "(", "word", ")", ")", "{", "continue", ";", "}", "list", ".", "add", "(", "word", ")", ";", "}", "if", "(", "list", ".", "size", "(", ")", "<=", "1", ")", "{", "LOG", ".", "warn", "(", "Arrays", ".", "toString", "(", "words", ")", "+", "\" not have any change because it less than 2 word\"", ")", ";", "return", ";", "}", "Set", "<", "String", ">", "set", "=", "findAllWords", "(", "key", ",", "words", ")", ";", "for", "(", "String", "word", ":", "list", ")", "{", "set", ".", "remove", "(", "word", ")", ";", "synonyms", ".", "add", "(", "word", ",", "list", ")", ";", "}", "for", "(", "String", "word", ":", "set", ")", "{", "//删除所有", "synonyms", ".", "remove", "(", "word", ")", ";", "synonyms", ".", "getBranch", "(", "word", ")", ".", "setParam", "(", "null", ")", ";", "}", "}" ]

[ "覆盖更新同义词", "[", "中国", "中华", "我国", "]", "-", ">", "replace", "(", "[", "中国", "华夏", "]", ")", "-", ">", "[", "中国", "华夏", "]" ]

[ "public", "static", "void", "writelnTo", "(", "String", "html", ",", "Writer", "writer", ")", "throws", "IOException", "{", "writeTo", "(", "html", ",", "writer", ")", ";", "writer", ".", "write", "(", "'", "'", ")", ";", "}" ]

[ "Écrit", "un", "texte", "puis", "un", "retour", "chariot", "dans", "un", "flux", "en", "remplaçant", "dans", "le", "texte", "les", "clés", "entourées", "de", "deux", "#", "par", "leurs", "traductions", "dans", "la", "locale", "courante", "." ]

[ "public", "String", "formatMessage", "(", "String", "key", ",", "Object", "[", "]", "args", ")", "{", "assert", "_resourceProvider", "!=", "null", ":", "\"Received a null resource provider\"", ";", "return", "_resourceProvider", ".", "formatMessage", "(", "key", ",", "args", ")", ";", "}" ]

[ "Format", "a", "message", "given", "a", "resource", "string", "name", "<code", ">", "key<", "/", "code", ">", "and", "a", "set", "of", "formatting", "arguments", "<code", ">", "args<", "/", "code", ">", "." ]

[ "@", "Override", "public", "boolean", "handleMessage", "(", "SOAPMessageContext", "context", ")", "{", "if", "(", "(", "Boolean", ")", "context", ".", "get", "(", "MessageContext", ".", "MESSAGE_OUTBOUND_PROPERTY", ")", ")", "{", "// Outbound message (request), so reset the last request and response builders.", "lastRequestInfo", "=", "new", "RequestInfo", ".", "Builder", "(", ")", ";", "lastResponseInfo", "=", "new", "ResponseInfo", ".", "Builder", "(", ")", ";", "SOAPMessage", "soapMessage", "=", "context", ".", "getMessage", "(", ")", ";", "try", "{", "SOAPHeader", "soapHeader", "=", "soapMessage", ".", "getSOAPHeader", "(", ")", ";", "if", "(", "soapHeader", "==", "null", ")", "{", "soapHeader", "=", "soapMessage", ".", "getSOAPPart", "(", ")", ".", "getEnvelope", "(", ")", ".", "addHeader", "(", ")", ";", "}", "for", "(", "SOAPElement", "header", ":", "soapHeaders", ")", "{", "soapHeader", ".", "addChildElement", "(", "header", ")", ";", "}", "}", "catch", "(", "SOAPException", "e", ")", "{", "throw", "new", "ServiceException", "(", "\"Error setting SOAP headers on outbound message.\"", ",", "e", ")", ";", "}", "captureServiceAndOperationNames", "(", "context", ")", ";", "}", "captureSoapXml", "(", "context", ")", ";", "return", "true", ";", "}" ]

[ "Captures", "pertinent", "information", "from", "SOAP", "messages", "exchanged", "by", "the", "SOAP", "service", "this", "handler", "is", "attached", "to", ".", "Also", "responsible", "for", "placing", "custom", "(", "implicit", ")", "SOAP", "headers", "on", "outgoing", "messages", "." ]

[ "public", "static", "Dir", "fromURL", "(", "final", "URL", "url", ",", "final", "UrlType", "...", "urlTypes", ")", "{", "return", "fromURL", "(", "url", ",", "Lists", ".", "<", "UrlType", ">", "newArrayList", "(", "urlTypes", ")", ")", ";", "}" ]

[ "tries", "to", "create", "a", "Dir", "from", "the", "given", "url", "using", "the", "given", "urlTypes" ]

[ "public", "Observable", "<", "CredentialResultsInner", ">", "listClusterAdminCredentialsAsync", "(", "String", "resourceGroupName", ",", "String", "resourceName", ")", "{", "return", "listClusterAdminCredentialsWithServiceResponseAsync", "(", "resourceGroupName", ",", "resourceName", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "CredentialResultsInner", ">", ",", "CredentialResultsInner", ">", "(", ")", "{", "@", "Override", "public", "CredentialResultsInner", "call", "(", "ServiceResponse", "<", "CredentialResultsInner", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Gets", "cluster", "admin", "credential", "of", "a", "managed", "cluster", ".", "Gets", "cluster", "admin", "credential", "of", "the", "managed", "cluster", "with", "a", "specified", "resource", "group", "and", "name", "." ]

[ "protected", "double", "computeCandidateWeight", "(", "Classifier", "candidate", ",", "Instances", "chunk", ",", "int", "numFolds", ")", "{", "double", "candidateWeight", "=", "0.0", ";", "Random", "random", "=", "new", "Random", "(", "1", ")", ";", "Instances", "randData", "=", "new", "Instances", "(", "chunk", ")", ";", "randData", ".", "randomize", "(", "random", ")", ";", "if", "(", "randData", ".", "classAttribute", "(", ")", ".", "isNominal", "(", ")", ")", "{", "randData", ".", "stratify", "(", "numFolds", ")", ";", "}", "for", "(", "int", "n", "=", "0", ";", "n", "<", "numFolds", ";", "n", "++", ")", "{", "Instances", "train", "=", "randData", ".", "trainCV", "(", "numFolds", ",", "n", ",", "random", ")", ";", "Instances", "test", "=", "randData", ".", "testCV", "(", "numFolds", ",", "n", ")", ";", "Classifier", "learner", "=", "candidate", ".", "copy", "(", ")", ";", "for", "(", "int", "num", "=", "0", ";", "num", "<", "train", ".", "numInstances", "(", ")", ";", "num", "++", ")", "{", "learner", ".", "trainOnInstance", "(", "train", ".", "instance", "(", "num", ")", ")", ";", "}", "candidateWeight", "+=", "computeWeight", "(", "learner", ",", "test", ")", ";", "}", "double", "resultWeight", "=", "candidateWeight", "/", "numFolds", ";", "if", "(", "Double", ".", "isInfinite", "(", "resultWeight", ")", ")", "{", "return", "Double", ".", "MAX_VALUE", ";", "}", "else", "{", "return", "resultWeight", ";", "}", "}" ]

[ "Computes", "the", "weight", "of", "a", "candidate", "classifier", "." ]

[ "private", "boolean", "notDelayedStyle", "(", "Chunk", "c", ",", "String", "gt", ",", "Collection", "<", "?", "extends", "BaseStyler", ">", "stylers", ")", "{", "if", "(", "stylers", "==", "null", ")", "{", "return", "true", ";", "}", "try", "{", "Collection", "<", "Advanced", ">", "a", "=", "new", "ArrayList", "<>", "(", "stylers", ".", "size", "(", ")", ")", ";", "for", "(", "Advanced", "adv", ":", "StyleHelper", ".", "getStylers", "(", "stylers", ",", "Advanced", ".", "class", ")", ")", "{", "Advanced", ".", "EVENTMODE", "mode", "=", "adv", ".", "getEventmode", "(", ")", ";", "if", "(", "Advanced", ".", "EVENTMODE", ".", "ALL", ".", "equals", "(", "mode", ")", "||", "Advanced", ".", "EVENTMODE", ".", "TEXT", ".", "equals", "(", "mode", ")", ")", "{", "// remember data and chunk", "adv", ".", "addDelayedData", "(", "gt", ",", "c", ")", ";", "a", ".", "add", "(", "adv", ")", ";", "}", "}", "if", "(", "a", ".", "size", "(", ")", ">", "0", ")", "{", "styleHelper", ".", "delayedStyle", "(", "c", ",", "gt", ",", "a", ",", "ph", ")", ";", "return", "false", ";", "}", "}", "catch", "(", "VectorPrintException", "ex", ")", "{", "log", ".", "log", "(", "Level", ".", "SEVERE", ",", "null", ",", "ex", ")", ";", "}", "return", "true", ";", "}" ]

[ "register", "advanced", "stylers", "together", "with", "data", "(", "part", ")", "with", "the", "EventHelper", "to", "do", "the", "styling", "later" ]

[ "public", "static", "String", "render", "(", "Template", "template", ",", "Map", "<", "String", ",", "Object", ">", "bindingMap", ")", "{", "template", ".", "binding", "(", "bindingMap", ")", ";", "return", "template", ".", "render", "(", ")", ";", "}" ]

[ "渲染模板" ]

[ "public", "static", "boolean", "updateComponentError", "(", "AbstractComponent", "component", ",", "ErrorMessage", "error", ")", "{", "if", "(", "component", ".", "getComponentError", "(", ")", "!=", "error", ")", "{", "component", ".", "setComponentError", "(", "error", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Updates", "the", "component", "error", "of", "a", "component", "but", "only", "if", "it", "differs", "from", "the", "currently", "set", "error", ".", "<p", ">" ]

[ "public", "Timestamp", "getTimestamp", "(", "final", "int", "columnIndex", ",", "final", "Calendar", "cal", ")", "throws", "SQLException", "{", "try", "{", "final", "Timestamp", "result", "=", "getValueObject", "(", "columnIndex", ")", ".", "getTimestamp", "(", "cal", ")", ";", "if", "(", "result", "==", "null", ")", "{", "return", "null", ";", "}", "return", "new", "Timestamp", "(", "result", ".", "getTime", "(", ")", ")", ";", "}", "catch", "(", "ParseException", "e", ")", "{", "throw", "SQLExceptionMapper", ".", "getSQLException", "(", "\"Could not parse as time\"", ")", ";", "}", "}" ]

[ "Retrieves", "the", "value", "of", "the", "designated", "column", "in", "the", "current", "row", "of", "this", "<code", ">", "ResultSet<", "/", "code", ">", "object", "as", "a", "<code", ">", "java", ".", "sql", ".", "Timestamp<", "/", "code", ">", "object", "in", "the", "Java", "programming", "language", ".", "This", "method", "uses", "the", "given", "calendar", "to", "construct", "an", "appropriate", "millisecond", "value", "for", "the", "timestamp", "if", "the", "underlying", "database", "does", "not", "store", "timezone", "information", "." ]

[ "private", "CompletableFuture", "<", "Revision", ">", "replacePermissionAtPointer", "(", "Author", "author", ",", "String", "projectName", ",", "JsonPointer", "path", ",", "Collection", "<", "Permission", ">", "permission", ",", "String", "commitSummary", ")", "{", "final", "Change", "<", "JsonNode", ">", "change", "=", "Change", ".", "ofJsonPatch", "(", "METADATA_JSON", ",", "new", "ReplaceOperation", "(", "path", ",", "Jackson", ".", "valueToTree", "(", "permission", ")", ")", ".", "toJsonNode", "(", ")", ")", ";", "return", "metadataRepo", ".", "push", "(", "projectName", ",", "Project", ".", "REPO_DOGMA", ",", "author", ",", "commitSummary", ",", "change", ")", ";", "}" ]

[ "Replaces", "{" ]

[ "public", "void", "forPairs", "(", "BiConsumer", "<", "?", "super", "T", ",", "?", "super", "T", ">", "action", ")", "{", "pairMap", "(", "(", "a", ",", "b", ")", "->", "{", "action", ".", "accept", "(", "a", ",", "b", ")", ";", "return", "null", ";", "}", ")", ".", "reduce", "(", "null", ",", "selectFirst", "(", ")", ")", ";", "}" ]

[ "Performs", "an", "action", "for", "each", "adjacent", "pair", "of", "elements", "of", "this", "stream", "." ]

[ "public", "static", "CacheableYamlSource", "sourceFromStream", "(", "final", "String", "identity", ",", "final", "InputStream", "stream", ",", "final", "Date", "modified", ",", "final", "ValidationSet", "validationSet", ")", "{", "return", "new", "CacheableYamlStreamSource", "(", "stream", ",", "identity", ",", "modified", ",", "validationSet", ")", ";", "}" ]

[ "Source", "from", "a", "stream" ]

[ "@", "Override", "public", "Node", "getUser", "(", "final", "String", "uid", ")", "{", "try", "{", "String", "query", "=", "\"(&(objectClass=\"", "+", "userObjectClass", "+", "\")(\"", "+", "userIdentifyer", "+", "\"=\"", "+", "uid", "+", "\"))\"", ";", "SearchResult", "searchResult", ";", "Attributes", "attributes", ";", "SearchControls", "controls", "=", "new", "SearchControls", "(", ")", ";", "controls", ".", "setReturningAttributes", "(", "new", "String", "[", "]", "{", "LdapKeys", ".", "ASTERISK", ",", "LdapKeys", ".", "MODIFY_TIMESTAMP", ",", "LdapKeys", ".", "MODIFIERS_NAME", ",", "LdapKeys", ".", "ENTRY_UUID", "}", ")", ";", "controls", ".", "setSearchScope", "(", "SearchControls", ".", "SUBTREE_SCOPE", ")", ";", "NamingEnumeration", "<", "SearchResult", ">", "results", "=", "ctx", ".", "search", "(", "\"\"", ",", "query", ",", "controls", ")", ";", "queryCount", "++", ";", "if", "(", "results", ".", "hasMore", "(", ")", ")", "{", "searchResult", "=", "results", ".", "next", "(", ")", ";", "attributes", "=", "searchResult", ".", "getAttributes", "(", ")", ";", "LdapUser", "user", "=", "new", "LdapUser", "(", "uid", ",", "this", ")", ";", "user", ".", "setDn", "(", "searchResult", ".", "getNameInNamespace", "(", ")", ")", ";", "user", "=", "fillAttributesInUser", "(", "(", "LdapUser", ")", "user", ",", "attributes", ")", ";", "return", "user", ";", "}", "}", "catch", "(", "NamingException", "ex", ")", "{", "handleNamingException", "(", "instanceName", "+", "\":\"", "+", "uid", ",", "ex", ")", ";", "}", "return", "new", "LdapUser", "(", ")", ";", "}" ]

[ "Returns", "an", "LDAP", "-", "User", "." ]

[ "public", "Observable", "<", "String", ">", "getVpnProfilePackageUrlAsync", "(", "String", "resourceGroupName", ",", "String", "virtualNetworkGatewayName", ")", "{", "return", "getVpnProfilePackageUrlWithServiceResponseAsync", "(", "resourceGroupName", ",", "virtualNetworkGatewayName", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "String", ">", ",", "String", ">", "(", ")", "{", "@", "Override", "public", "String", "call", "(", "ServiceResponse", "<", "String", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Gets", "pre", "-", "generated", "VPN", "profile", "for", "P2S", "client", "of", "the", "virtual", "network", "gateway", "in", "the", "specified", "resource", "group", ".", "The", "profile", "needs", "to", "be", "generated", "first", "using", "generateVpnProfile", "." ]

[ "public", "static", "final", "Direction", "getQuadrant", "(", "final", "double", "cx", ",", "final", "double", "cy", ",", "final", "double", "x0", ",", "final", "double", "y0", ")", "{", "if", "(", "(", "x0", ">", "cx", ")", "&&", "(", "y0", "<", "cy", ")", ")", "{", "return", "Direction", ".", "NORTH_EAST", ";", "}", "if", "(", "(", "x0", ">", "cx", ")", "&&", "(", "y0", ">=", "cy", ")", ")", "{", "return", "Direction", ".", "SOUTH_EAST", ";", "}", "if", "(", "(", "x0", "<=", "cx", ")", "&&", "(", "y0", ">=", "cy", ")", ")", "{", "return", "Direction", ".", "SOUTH_WEST", ";", "}", "// if( x0 <= c.getX() && y0 < c.getY() )\r", "return", "Direction", ".", "NORTH_WEST", ";", "}" ]

[ "Returns", "the", "NESW", "quadrant", "the", "point", "is", "in", ".", "The", "delta", "from", "the", "center", "NE", "x", ">", "0", "y", "<", "0", "SE", "x", ">", "0", "y", ">", "=", "0", "SW", "x", "<", "=", "0", "y", ">", "=", "0", "NW", "x", "<", "=", "0", "y", "<", "0" ]

[ "private", "static", "URL", "clearUserInfo", "(", "String", "systemID", ")", "{", "try", "{", "URL", "url", "=", "new", "URL", "(", "systemID", ")", ";", "// Do not clear user info on \"file\" urls 'cause on Windows the drive will", "// have no \":\"...", "if", "(", "!", "\"file\"", ".", "equals", "(", "url", ".", "getProtocol", "(", ")", ")", ")", "{", "return", "attachUserInfo", "(", "url", ",", "null", ",", "null", ")", ";", "}", "return", "url", ";", "}", "catch", "(", "MalformedURLException", "e", ")", "{", "return", "null", ";", "}", "}" ]

[ "Clears", "the", "user", "info", "from", "an", "url", "." ]

[ "public", "@", "Nonnull", "JsonBuilder", "putArray", "(", "String", "key", ",", "String", "...", "values", ")", "{", "JsonArray", "jjArray", "=", "new", "JsonArray", "(", ")", ";", "for", "(", "String", "string", ":", "values", ")", "{", "jjArray", ".", "add", "(", "primitive", "(", "string", ")", ")", ";", "}", "object", ".", "put", "(", "key", ",", "jjArray", ")", ";", "return", "this", ";", "}" ]

[ "Add", "a", "JsonArray", "to", "the", "object", "with", "the", "string", "values", "added", "." ]

[ "public", "static", "int", "cuGraphicsMapResources", "(", "int", "count", ",", "CUgraphicsResource", "resources", "[", "]", ",", "CUstream", "hStream", ")", "{", "return", "checkResult", "(", "cuGraphicsMapResourcesNative", "(", "count", ",", "resources", ",", "hStream", ")", ")", ";", "}" ]

[ "Map", "graphics", "resources", "for", "access", "by", "CUDA", "." ]

[ "private", "double", "densityThresholdFunction", "(", "int", "tg", ",", "double", "cl", ",", "double", "decayFactor", ",", "int", "N", ")", "{", "return", "(", "cl", "*", "(", "1.0", "-", "Math", ".", "pow", "(", "decayFactor", ",", "(", "this", ".", "getCurrTime", "(", ")", "-", "tg", "+", "1.0", ")", ")", ")", ")", "/", "(", "N", "*", "(", "1.0", "-", "decayFactor", ")", ")", ";", "}" ]

[ "Implements", "the", "function", "pi", "given", "in", "Definition", "4", ".", "1", "of", "Chen", "and", "Tu", "2007" ]

[ "public", "void", "purchaseReservedInstance", "(", "String", "instanceId", ",", "int", "reservationLength", ",", "String", "reservationTimeUnit", ")", "{", "this", ".", "purchaseReservedInstance", "(", "new", "PurchaseReservedInstanceRequeset", "(", ")", ".", "withInstanceId", "(", "instanceId", ")", ".", "withBilling", "(", "new", "Billing", "(", ")", ".", "withReservation", "(", "new", "Reservation", "(", ")", ".", "withReservationLength", "(", "reservationLength", ")", ".", "withReservationTimeUnit", "(", "reservationTimeUnit", ")", ")", ")", ")", ";", "}" ]

[ "PurchaseReserved", "the", "instance", "with", "fixed", "duration", "." ]

[ "public", "User", "createUser", "(", "final", "User", "user", ",", "final", "String", "userPass", ")", "throws", "SQLException", "{", "Connection", "conn", "=", "null", ";", "PreparedStatement", "stmt", "=", "null", ";", "ResultSet", "rs", "=", "null", ";", "String", "nicename", "=", "user", ".", "slug", ";", "if", "(", "nicename", ".", "length", "(", ")", ">", "49", ")", "{", "nicename", "=", "nicename", ".", "substring", "(", "0", ",", "49", ")", ";", "}", "String", "username", "=", "user", ".", "username", ".", "length", "(", ")", "<", "60", "?", "user", ".", "username", ":", "user", ".", "username", ".", "substring", "(", "0", ",", "60", ")", ";", "Timer", ".", "Context", "ctx", "=", "metrics", ".", "createUserTimer", ".", "time", "(", ")", ";", "try", "{", "conn", "=", "connectionSupplier", ".", "getConnection", "(", ")", ";", "if", "(", "user", ".", "id", ">", "0L", ")", "{", "stmt", "=", "conn", ".", "prepareStatement", "(", "createUserWithIdSQL", ")", ";", "stmt", ".", "setLong", "(", "1", ",", "user", ".", "id", ")", ";", "stmt", ".", "setString", "(", "2", ",", "username", ")", ";", "stmt", ".", "setString", "(", "3", ",", "Strings", ".", "nullToEmpty", "(", "userPass", ")", ")", ";", "stmt", ".", "setString", "(", "4", ",", "nicename", ")", ";", "stmt", ".", "setString", "(", "5", ",", "user", ".", "displayName", "(", ")", ")", ";", "stmt", ".", "setString", "(", "6", ",", "Strings", ".", "nullToEmpty", "(", "user", ".", "email", ")", ")", ";", "stmt", ".", "setString", "(", "7", ",", "Strings", ".", "nullToEmpty", "(", "user", ".", "url", ")", ")", ";", "stmt", ".", "executeUpdate", "(", ")", ";", "return", "user", ";", "}", "else", "{", "stmt", "=", "conn", ".", "prepareStatement", "(", "createUserSQL", ",", "Statement", ".", "RETURN_GENERATED_KEYS", ")", ";", "stmt", ".", "setString", "(", "1", ",", "username", ")", ";", "stmt", ".", "setString", "(", "2", ",", "Strings", ".", "nullToEmpty", "(", "userPass", ")", ")", ";", "stmt", ".", "setString", "(", "3", ",", "nicename", ")", ";", "stmt", ".", "setString", "(", "4", ",", "user", ".", "displayName", "(", ")", ")", ";", "stmt", ".", "setString", "(", "5", ",", "Strings", ".", "nullToEmpty", "(", "user", ".", "email", ")", ")", ";", "stmt", ".", "setString", "(", "6", ",", "Strings", ".", "nullToEmpty", "(", "user", ".", "url", ")", ")", ";", "stmt", ".", "executeUpdate", "(", ")", ";", "rs", "=", "stmt", ".", "getGeneratedKeys", "(", ")", ";", "if", "(", "rs", ".", "next", "(", ")", ")", "{", "return", "user", ".", "withId", "(", "rs", ".", "getLong", "(", "1", ")", ")", ";", "}", "else", "{", "throw", "new", "SQLException", "(", "\"Problem creating user (no generated id)\"", ")", ";", "}", "}", "}", "finally", "{", "ctx", ".", "stop", "(", ")", ";", "closeQuietly", "(", "conn", ",", "stmt", ",", "rs", ")", ";", "}", "}" ]

[ "Creates", "a", "user", ".", "<p", ">", "If", "the", "{" ]

[ "public", "boolean", "verifySignature", "(", "Map", "<", "String", ",", "String", ">", "parsedMessage", ",", "PublicKey", "publicKey", ")", "{", "boolean", "valid", "=", "false", ";", "String", "version", "=", "parsedMessage", ".", "get", "(", "SIGNATURE_VERSION", ")", ";", "if", "(", "version", ".", "equals", "(", "\"1\"", ")", ")", "{", "// construct the canonical signed string", "String", "type", "=", "parsedMessage", ".", "get", "(", "TYPE", ")", ";", "String", "signature", "=", "parsedMessage", ".", "get", "(", "SIGNATURE", ")", ";", "String", "signed", ";", "if", "(", "type", ".", "equals", "(", "NOTIFICATION_TYPE", ")", ")", "{", "signed", "=", "stringToSign", "(", "publishMessageValues", "(", "parsedMessage", ")", ")", ";", "}", "else", "if", "(", "type", ".", "equals", "(", "SUBSCRIBE_TYPE", ")", ")", "{", "signed", "=", "stringToSign", "(", "subscribeMessageValues", "(", "parsedMessage", ")", ")", ";", "}", "else", "if", "(", "type", ".", "equals", "(", "UNSUBSCRIBE_TYPE", ")", ")", "{", "signed", "=", "stringToSign", "(", "subscribeMessageValues", "(", "parsedMessage", ")", ")", ";", "// no difference, for now", "}", "else", "{", "throw", "new", "RuntimeException", "(", "\"Cannot process message of type \"", "+", "type", ")", ";", "}", "valid", "=", "verifySignature", "(", "signed", ",", "signature", ",", "publicKey", ")", ";", "}", "return", "valid", ";", "}" ]

[ "Validates", "the", "signature", "on", "a", "Simple", "Notification", "Service", "message", ".", "No", "Amazon", "-", "specific", "dependencies", "just", "plain", "Java", "crypto" ]

[ "public", "static", "String", "unCamel", "(", "String", "str", ",", "char", "seperator", ",", "boolean", "lowercase", ")", "{", "char", "[", "]", "ca", "=", "str", ".", "toCharArray", "(", ")", ";", "if", "(", "3", ">", "ca", ".", "length", ")", "{", "return", "lowercase", "?", "str", ".", "toLowerCase", "(", ")", ":", "str", ";", "}", "// about five seperator", "StringBuilder", "build", "=", "new", "StringBuilder", "(", "ca", ".", "length", "+", "5", ")", ";", "build", ".", "append", "(", "lowercase", "?", "toLowerCase", "(", "ca", "[", "0", "]", ")", ":", "ca", "[", "0", "]", ")", ";", "boolean", "lower1", "=", "isLowerCase", "(", "ca", "[", "0", "]", ")", ";", "int", "i", "=", "1", ";", "while", "(", "i", "<", "ca", ".", "length", "-", "1", ")", "{", "char", "cur", "=", "ca", "[", "i", "]", ";", "char", "next", "=", "ca", "[", "i", "+", "1", "]", ";", "boolean", "upper2", "=", "isUpperCase", "(", "cur", ")", ";", "boolean", "lower3", "=", "isLowerCase", "(", "next", ")", ";", "if", "(", "lower1", "&&", "upper2", "&&", "lower3", ")", "{", "build", ".", "append", "(", "seperator", ")", ";", "build", ".", "append", "(", "lowercase", "?", "toLowerCase", "(", "cur", ")", ":", "cur", ")", ";", "build", ".", "append", "(", "next", ")", ";", "i", "+=", "2", ";", "}", "else", "{", "if", "(", "lowercase", "&&", "upper2", ")", "{", "build", ".", "append", "(", "toLowerCase", "(", "cur", ")", ")", ";", "}", "else", "{", "build", ".", "append", "(", "cur", ")", ";", "}", "lower1", "=", "!", "upper2", ";", "i", "++", ";", "}", "}", "if", "(", "i", "==", "ca", ".", "length", "-", "1", ")", "{", "build", ".", "append", "(", "lowercase", "?", "toLowerCase", "(", "ca", "[", "i", "]", ")", ":", "ca", "[", "i", "]", ")", ";", "}", "return", "build", ".", "toString", "(", ")", ";", "}" ]

[ "将驼峰表示法转换为下划线小写表示" ]

[ "protected", "Object", "readResolve", "(", ")", "throws", "ObjectStreamException", "{", "try", "{", "if", "(", "type", "==", "Type", ".", "SECRET", "&&", "RAW", ".", "equals", "(", "format", ")", ")", "{", "return", "new", "SecretKeySpec", "(", "encoded", ",", "algorithm", ")", ";", "}", "else", "if", "(", "type", "==", "Type", ".", "PUBLIC", "&&", "X509", ".", "equals", "(", "format", ")", ")", "{", "KeyFactory", "f", "=", "KeyFactory", ".", "getInstance", "(", "algorithm", ")", ";", "return", "f", ".", "generatePublic", "(", "new", "X509EncodedKeySpec", "(", "encoded", ")", ")", ";", "}", "else", "if", "(", "type", "==", "Type", ".", "PRIVATE", "&&", "PKCS8", ".", "equals", "(", "format", ")", ")", "{", "KeyFactory", "f", "=", "KeyFactory", ".", "getInstance", "(", "algorithm", ")", ";", "return", "f", ".", "generatePrivate", "(", "new", "PKCS8EncodedKeySpec", "(", "encoded", ")", ")", ";", "}", "else", "{", "throw", "new", "NotSerializableException", "(", "\"unrecognized type/format combination: \"", "+", "type", "+", "\"/\"", "+", "format", ")", ";", "}", "}", "catch", "(", "NotSerializableException", "nse", ")", "{", "throw", "nse", ";", "}", "catch", "(", "Exception", "e", ")", "{", "NotSerializableException", "nse", "=", "new", "NotSerializableException", "(", "\"java.security.Key: \"", "+", "\"[\"", "+", "type", "+", "\"] \"", "+", "\"[\"", "+", "algorithm", "+", "\"] \"", "+", "\"[\"", "+", "format", "+", "\"]\"", ")", ";", "nse", ".", "initCause", "(", "e", ")", ";", "throw", "nse", ";", "}", "}" ]

[ "Resolve", "the", "Key", "object", "." ]

[ "public", "WebDavServletController", "createWebDavServlet", "(", "Path", "rootPath", ",", "String", "contextPath", ")", "{", "WebDavServletComponent", "servletComp", "=", "servletFactory", ".", "create", "(", "rootPath", ",", "contextPath", ")", ";", "return", "servletComp", ".", "servlet", "(", ")", ";", "}" ]

[ "Creates", "a", "new", "WebDAV", "servlet", "(", "without", "starting", "it", "yet", ")", "." ]

[ "public", "BoxHttpRequest", "addHeader", "(", "String", "key", ",", "String", "value", ")", "{", "mUrlConnection", ".", "addRequestProperty", "(", "key", ",", "value", ")", ";", "return", "this", ";", "}" ]

[ "Adds", "an", "HTTP", "header", "to", "the", "request", "." ]

[ "public", "boolean", "syncClonedListener", "(", "BaseField", "field", ",", "FieldListener", "listener", ",", "boolean", "bInitCalled", ")", "{", "if", "(", "!", "bInitCalled", ")", "(", "(", "CopySoundexHandler", ")", "listener", ")", ".", "init", "(", "null", ",", "m_iFieldSeq", ")", ";", "return", "super", ".", "syncClonedListener", "(", "field", ",", "listener", ",", "true", ")", ";", "}" ]

[ "Set", "this", "cloned", "listener", "to", "the", "same", "state", "at", "this", "listener", "." ]

[ "public", "final", "void", "cacheStatement", "(", "Statement", "statement", ",", "StatementCacheKey", "key", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEventEnabled", "(", ")", ")", "Tr", ".", "event", "(", "this", ",", "tc", ",", "\"cacheStatement\"", ",", "AdapterUtil", ".", "toString", "(", "statement", ")", ",", "key", ")", ";", "// Add the statement to the cache. If there is no room in the cache, a statement from", "// the least recently used bucket will be cast out of the cache. Any statement cast", "// out of the cache must be closed. ", "CacheMap", "cache", "=", "getStatementCache", "(", ")", ";", "Object", "discardedStatement", "=", "cache", "==", "null", "?", "statement", ":", "statementCache", ".", "add", "(", "key", ",", "statement", ")", ";", "if", "(", "discardedStatement", "!=", "null", ")", "destroyStatement", "(", "discardedStatement", ")", ";", "}" ]

[ "Returns", "the", "statement", "into", "the", "cache", ".", "The", "statement", "is", "closed", "if", "an", "error", "occurs", "attempting", "to", "cache", "it", ".", "This", "method", "will", "only", "called", "if", "statement", "caching", "was", "enabled", "at", "some", "point", "although", "it", "might", "not", "be", "enabled", "anymore", "." ]

[ "public", "Section", "addContextAndScopeSection", "(", "SoftwareSystem", "softwareSystem", ",", "File", "...", "files", ")", "throws", "IOException", "{", "return", "addSection", "(", "softwareSystem", ",", "\"Context and Scope\"", ",", "files", ")", ";", "}" ]

[ "Adds", "a", "Context", "and", "Scope", "section", "relating", "to", "a", "{", "@link", "SoftwareSystem", "}", "from", "one", "or", "more", "files", "." ]

[ "public", "static", "File", "getExecutableLocation", "(", "final", "String", "exeName", ")", "{", "//", "// must add current working directory to the", "// from of the path from the \"path\" environment variable", "final", "File", "currentDir", "=", "new", "File", "(", "System", ".", "getProperty", "(", "\"user.dir\"", ")", ")", ";", "if", "(", "new", "File", "(", "currentDir", ",", "exeName", ")", ".", "exists", "(", ")", ")", "{", "return", "currentDir", ";", "}", "final", "File", "[", "]", "envPath", "=", "CUtil", ".", "getPathFromEnvironment", "(", "\"PATH\"", ",", "File", ".", "pathSeparator", ")", ";", "for", "(", "final", "File", "element", ":", "envPath", ")", "{", "if", "(", "new", "File", "(", "element", ",", "exeName", ")", ".", "exists", "(", ")", ")", "{", "return", "element", ";", "}", "}", "return", "null", ";", "}" ]

[ "Gets", "the", "parent", "directory", "for", "the", "executable", "file", "name", "using", "the", "current", "directory", "and", "system", "executable", "path" ]

[ "public", "static", "boolean", "containsIgnoreCase", "(", "final", "CharSequence", "str", ",", "final", "CharSequence", "searchStr", ")", "{", "if", "(", "str", "==", "null", "||", "searchStr", "==", "null", ")", "{", "return", "false", ";", "}", "final", "int", "len", "=", "searchStr", ".", "length", "(", ")", ";", "final", "int", "max", "=", "str", ".", "length", "(", ")", "-", "len", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<=", "max", ";", "i", "++", ")", "{", "if", "(", "CharSequenceUtils", ".", "regionMatches", "(", "str", ",", "true", ",", "i", ",", "searchStr", ",", "0", ",", "len", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "<p", ">", "Checks", "if", "CharSequence", "contains", "a", "search", "CharSequence", "irrespective", "of", "case", "handling", "{", "@code", "null", "}", ".", "Case", "-", "insensitivity", "is", "defined", "as", "by", "{", "@link", "String#equalsIgnoreCase", "(", "String", ")", "}", "." ]

[ "@", "ArgumentsChecked", "@", "Throws", "(", "{", "IllegalNullArgumentException", ".", "class", ",", "IllegalEmptyArgumentException", ".", "class", "}", ")", "public", "static", "void", "notEmpty", "(", "final", "boolean", "condition", ",", "final", "boolean", "expression", ")", "{", "if", "(", "condition", ")", "{", "Check", ".", "notEmpty", "(", "expression", ")", ";", "}", "}" ]

[ "Ensures", "that", "a", "passed", "parameter", "of", "the", "calling", "method", "is", "not", "empty", "using", "the", "passed", "expression", "to", "evaluate", "the", "emptiness", "." ]

[ "public", "static", "Map", "<", "String", ",", "String", ">", "mapBean", "(", "final", "Object", "bean", ",", "final", "String", "exclude", ")", "{", "final", "Set", "<", "String", ">", "excludes", "=", "new", "HashSet", "<", "String", ">", "(", ")", ";", "if", "(", "!", "StringUtils", ".", "isBlank", "(", "exclude", ")", ")", "{", "excludes", ".", "add", "(", "exclude", ")", ";", "}", "return", "mapBean", "(", "bean", ",", "excludes", ")", ";", "}" ]

[ "Creates", "a", "{", "@link", "Map", "}", "from", "all", "bean", "data", "get", "methods", "except", "the", "one", "specified", "to", "exclude", ".", "Note", "that", "getClass", "is", "always", "excluded", "." ]

[ "@", "Override", "public", "void", "applyUpdater", "(", "INDArray", "gradient", ",", "int", "iteration", ",", "int", "epoch", ")", "{", "if", "(", "v", "==", "null", ")", "throw", "new", "IllegalStateException", "(", "\"Updater has not been initialized with view state\"", ")", ";", "double", "momentum", "=", "config", ".", "currentMomentum", "(", "iteration", ",", "epoch", ")", ";", "double", "learningRate", "=", "config", ".", "getLearningRate", "(", "iteration", ",", "epoch", ")", ";", "//reference https://cs231n.github.io/neural-networks-3/#sgd 2nd equation", "//DL4J default is negative step function thus we flipped the signs:", "// x += mu * v_prev + (-1 - mu) * v", "//i.e., we do params -= updatedGradient, not params += updatedGradient", "//v = mu * v - lr * gradient", "INDArray", "vPrev", "=", "v", ".", "dup", "(", "gradientReshapeOrder", ")", ";", "v", ".", "muli", "(", "momentum", ")", ".", "subi", "(", "gradient", ".", "dup", "(", "gradientReshapeOrder", ")", ".", "muli", "(", "learningRate", ")", ")", ";", "//Modify state array in-place", "/*\n Next line is equivalent to:\n INDArray ret = vPrev.muli(momentum).addi(v.mul(-momentum - 1));\n gradient.assign(ret);\n */", "Nd4j", ".", "getExecutioner", "(", ")", ".", "exec", "(", "new", "OldAddOp", "(", "vPrev", ".", "muli", "(", "momentum", ")", ",", "v", ".", "mul", "(", "-", "momentum", "-", "1", ")", ",", "gradient", ")", ")", ";", "}" ]

[ "Get", "the", "nesterov", "update" ]

[ "public", "JSONObject", "createTask", "(", "String", "name", ",", "String", "templateContent", ",", "String", "inputMappingFile", ",", "String", "outputFile", ",", "String", "urlPattern", ",", "HashMap", "<", "String", ",", "String", ">", "options", ")", "{", "AipRequest", "request", "=", "new", "AipRequest", "(", ")", ";", "preOperation", "(", "request", ")", ";", "request", ".", "addBody", "(", "\"name\"", ",", "name", ")", ";", "request", ".", "addBody", "(", "\"template_content\"", ",", "templateContent", ")", ";", "request", ".", "addBody", "(", "\"input_mapping_file\"", ",", "inputMappingFile", ")", ";", "request", ".", "addBody", "(", "\"output_file\"", ",", "outputFile", ")", ";", "request", ".", "addBody", "(", "\"url_pattern\"", ",", "urlPattern", ")", ";", "if", "(", "options", "!=", "null", ")", "{", "request", ".", "addBody", "(", "options", ")", ";", "}", "request", ".", "setUri", "(", "KnowledgeGraphicConsts", ".", "CREATE_TASK", ")", ";", "postOperation", "(", "request", ")", ";", "return", "requestServer", "(", "request", ")", ";", "}" ]

[ "创建任务接口", "创建一个新的信息抽取任务" ]

[ "public", "void", "setStaticVariables", "(", "final", "Map", "<", "String", ",", "?", ">", "variables", ")", "{", "if", "(", "variables", "!=", "null", ")", "{", "if", "(", "this", ".", "staticVariables", "==", "null", ")", "{", "this", ".", "staticVariables", "=", "new", "HashMap", "<", "String", ",", "Object", ">", "(", "3", ",", "1.0f", ")", ";", "}", "this", ".", "staticVariables", ".", "putAll", "(", "variables", ")", ";", "}", "}" ]

[ "<p", ">", "Sets", "a", "set", "of", "static", "variables", "which", "will", "be", "available", "at", "the", "context", "when", "this", "view", "is", "processed", ".", "<", "/", "p", ">", "<p", ">", "This", "method", "<b", ">", "does", "not", "overwrite<", "/", "b", ">", "the", "existing", "static", "variables", "it", "simply", "adds", "the", "ones", "specify", "to", "any", "variables", "already", "registered", ".", "<", "/", "p", ">", "<p", ">", "These", "static", "variables", "are", "added", "to", "the", "context", "before", "this", "view", "is", "processed", "so", "that", "they", "can", "be", "referenced", "from", "the", "context", "like", "any", "other", "context", "variables", "for", "example", ":", "{", "@code", "$", "{", "myStaticVar", "}}", ".", "<", "/", "p", ">" ]

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

[ "Gets", "a", "share", "by", "name", "." ]

[ "public", "static", "void", "rectifyHToAbsoluteQuadratic", "(", "DMatrixRMaj", "H", ",", "DMatrixRMaj", "Q", ")", "{", "int", "indexQ", "=", "0", ";", "for", "(", "int", "rowA", "=", "0", ";", "rowA", "<", "4", ";", "rowA", "++", ")", "{", "for", "(", "int", "colB", "=", "0", ";", "colB", "<", "4", ";", "colB", "++", ")", "{", "int", "indexA", "=", "rowA", "*", "4", ";", "int", "indexB", "=", "colB", "*", "4", ";", "double", "sum", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "3", ";", "i", "++", ")", "{", "//\t\t\t\t\tsum += H.get(rowA,i)*H.get(colB,i);", "sum", "+=", "H", ".", "data", "[", "indexA", "++", "]", "*", "H", ".", "data", "[", "indexB", "++", "]", ";", "}", "//\t\t\t\tQ.set(rowA,colB,sum);", "Q", ".", "data", "[", "indexQ", "++", "]", "=", "sum", ";", "}", "}", "}" ]

[ "Rectifying", "homography", "to", "dual", "absolute", "quadratic", "." ]

[ "public", "String", "registerBlockListener", "(", "BlockingQueue", "<", "QueuedBlockEvent", ">", "blockEventQueue", ",", "long", "timeout", ",", "TimeUnit", "timeUnit", ")", "throws", "InvalidArgumentException", "{", "if", "(", "shutdown", ")", "{", "throw", "new", "InvalidArgumentException", "(", "format", "(", "\"Channel %s has been shutdown.\"", ",", "name", ")", ")", ";", "}", "if", "(", "null", "==", "blockEventQueue", ")", "{", "throw", "new", "InvalidArgumentException", "(", "\"BlockEventQueue parameter is null.\"", ")", ";", "}", "if", "(", "timeout", "<", "0L", ")", "{", "throw", "new", "InvalidArgumentException", "(", "format", "(", "\"Timeout parameter must be greater than 0 not %d\"", ",", "timeout", ")", ")", ";", "}", "if", "(", "null", "==", "timeUnit", ")", "{", "throw", "new", "InvalidArgumentException", "(", "\"TimeUnit parameter must not be null.\"", ")", ";", "}", "String", "handle", "=", "new", "BL", "(", "blockEventQueue", ",", "timeout", ",", "timeUnit", ")", ".", "getHandle", "(", ")", ";", "logger", ".", "trace", "(", "format", "(", "\"Register QueuedBlockEvent listener %s\"", ",", "handle", ")", ")", ";", "return", "handle", ";", "}" ]

[ "Register", "a", "Queued", "block", "listener", ".", "This", "queue", "should", "never", "block", "insertion", "of", "events", "." ]

[ "protected", "static", "EnvVars", "getEnvVars", "(", "Run", "run", ",", "TaskListener", "listener", ")", "throws", "IOException", ",", "InterruptedException", "{", "final", "EnvVars", "envVars", "=", "run", ".", "getCharacteristicEnvVars", "(", ")", ";", "// from run.getEnvironment(listener) but without computer vars", "for", "(", "EnvironmentContributor", "ec", ":", "EnvironmentContributor", ".", "all", "(", ")", ".", "reverseView", "(", ")", ")", "{", "// job vars", "ec", ".", "buildEnvironmentFor", "(", "run", ".", "getParent", "(", ")", ",", "envVars", ",", "listener", ")", ";", "// build vars", "if", "(", "ec", "instanceof", "CoreEnvironmentContributor", ")", "{", "// exclude executor computer related vars", "envVars", ".", "put", "(", "\"BUILD_DISPLAY_NAME\"", ",", "run", ".", "getDisplayName", "(", ")", ")", ";", "String", "rootUrl", "=", "Jenkins", ".", "getInstance", "(", ")", ".", "getRootUrl", "(", ")", ";", "if", "(", "rootUrl", "!=", "null", ")", "{", "envVars", ".", "put", "(", "\"BUILD_URL\"", ",", "rootUrl", "+", "run", ".", "getUrl", "(", ")", ")", ";", "}", "// and remove useless job var from CoreEnvironmentContributor", "envVars", ".", "remove", "(", "\"JENKINS_HOME\"", ")", ";", "envVars", ".", "remove", "(", "\"HUDSON_HOME\"", ")", ";", "}", "else", "{", "ec", ".", "buildEnvironmentFor", "(", "run", ",", "envVars", ",", "listener", ")", ";", "// build vars", "}", "}", "return", "envVars", ";", "}" ]

[ "Return", "all", "job", "related", "vars", "without", "executor", "vars", ".", "I", ".", "e", ".", "slave", "is", "running", "in", "osx", "but", "docker", "image", "for", "shell", "is", "linux", "." ]

[ "@", "CanIgnoreReturnValue", "@", "Override", "public", "V", "checkedGet", "(", "long", "timeout", ",", "TimeUnit", "unit", ")", "throws", "TimeoutException", ",", "X", "{", "try", "{", "return", "get", "(", "timeout", ",", "unit", ")", ";", "}", "catch", "(", "InterruptedException", "e", ")", "{", "Thread", ".", "currentThread", "(", ")", ".", "interrupt", "(", ")", ";", "throw", "mapException", "(", "e", ")", ";", "}", "catch", "(", "CancellationException", "e", ")", "{", "throw", "mapException", "(", "e", ")", ";", "}", "catch", "(", "ExecutionException", "e", ")", "{", "throw", "mapException", "(", "e", ")", ";", "}", "}" ]

[ "{", "@inheritDoc", "}" ]

[ "public", "static", "HttpResponse", "doPutResponse", "(", "String", "host", ",", "String", "path", ",", "Map", "<", "String", ",", "String", ">", "headers", ",", "Map", "<", "String", ",", "String", ">", "queries", ")", "throws", "Exception", "{", "return", "doPutResponse", "(", "host", ",", "path", ",", "headers", ",", "queries", ",", "\"\"", ")", ";", "}" ]

[ "Put", "String" ]

[ "protected", "String", "checkAgentUrl", "(", "Object", "pVm", ",", "int", "delayInMs", ")", "throws", "NoSuchMethodException", ",", "InvocationTargetException", ",", "IllegalAccessException", "{", "if", "(", "delayInMs", "!=", "0", ")", "{", "try", "{", "Thread", ".", "sleep", "(", "delayInMs", ")", ";", "}", "catch", "(", "InterruptedException", "e", ")", "{", "// just continue", "}", "}", "Properties", "systemProperties", "=", "getAgentSystemProperties", "(", "pVm", ")", ";", "return", "systemProperties", ".", "getProperty", "(", "JvmAgent", ".", "JOLOKIA_AGENT_URL", ")", ";", "}" ]

[ "Check", "whether", "an", "agent", "is", "registered", "by", "checking", "the", "existance", "of", "the", "system", "property", "{", "@link", "JvmAgent#JOLOKIA_AGENT_URL", "}", ".", "This", "can", "be", "used", "to", "check", "whether", "a", "Jolokia", "agent", "has", "been", "already", "attached", "and", "started", ".", "(", "start", "will", "set", "this", "property", "stop", "will", "remove", "it", ")", "." ]

[ "private", "URL", "extractResource", "(", "ZipEntry", "zipEntry", ")", "throws", "IOException", "{", "File", "resourceWorkDir", "=", "new", "File", "(", "workDir", ",", "\"resources\"", ")", ";", "if", "(", "!", "resourceWorkDir", ".", "exists", "(", ")", ")", "{", "resourceWorkDir", ".", "mkdirs", "(", ")", ";", "}", "File", "resourceFile", "=", "new", "File", "(", "resourceWorkDir", ",", "zipEntry", ".", "getName", "(", ")", ")", ";", "if", "(", "!", "resourceFile", ".", "isFile", "(", ")", ")", "{", "resourceFile", ".", "getParentFile", "(", ")", ".", "mkdirs", "(", ")", ";", "File", "tmpFile", "=", "File", ".", "createTempFile", "(", "\"res\"", ",", "\".tmp\"", ",", "resourceWorkDir", ")", ";", "tmpFile", ".", "deleteOnExit", "(", ")", ";", "InputStream", "input", "=", "null", ";", "OutputStream", "output", "=", "null", ";", "try", "{", "input", "=", "this", ".", "pluginArtifactZip", ".", "getInputStream", "(", "zipEntry", ")", ";", "output", "=", "new", "FileOutputStream", "(", "tmpFile", ")", ";", "IOUtils", ".", "copy", "(", "input", ",", "output", ")", ";", "output", ".", "flush", "(", ")", ";", "tmpFile", ".", "renameTo", "(", "resourceFile", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "e", ";", "}", "finally", "{", "IOUtils", ".", "closeQuietly", "(", "input", ")", ";", "IOUtils", ".", "closeQuietly", "(", "output", ")", ";", "}", "}", "return", "resourceFile", ".", "toURI", "(", ")", ".", "toURL", "(", ")", ";", "}" ]

[ "Extracts", "a", "resource", "from", "the", "plugin", "artifact", "ZIP", "and", "saves", "it", "to", "the", "work", "directory", ".", "If", "the", "resource", "has", "already", "been", "extracted", "(", "we", "re", "re", "-", "using", "the", "work", "directory", ")", "then", "this", "simply", "returns", "what", "is", "already", "there", "." ]

[ "protected", "FileResourceBundle", "createFileResourceBundle", "(", "File", "source", ",", "boolean", "delay", ",", "boolean", "unpack", ")", "{", "return", "new", "FileResourceBundle", "(", "source", ",", "delay", ",", "unpack", ")", ";", "}" ]

[ "Creates", "an", "appropriate", "bundle", "for", "fetching", "resources", "from", "files", "." ]

[ "public", "COPACNeighborPredicate", ".", "Instance", "instantiate", "(", "Database", "database", ",", "Relation", "<", "V", ">", "relation", ")", "{", "DistanceQuery", "<", "V", ">", "dq", "=", "database", ".", "getDistanceQuery", "(", "relation", ",", "EuclideanDistanceFunction", ".", "STATIC", ")", ";", "KNNQuery", "<", "V", ">", "knnq", "=", "database", ".", "getKNNQuery", "(", "dq", ",", "settings", ".", "k", ")", ";", "WritableDataStore", "<", "COPACModel", ">", "storage", "=", "DataStoreUtil", ".", "makeStorage", "(", "relation", ".", "getDBIDs", "(", ")", ",", "DataStoreFactory", ".", "HINT_HOT", "|", "DataStoreFactory", ".", "HINT_TEMP", ",", "COPACModel", ".", "class", ")", ";", "Duration", "time", "=", "LOG", ".", "newDuration", "(", "this", ".", "getClass", "(", ")", ".", "getName", "(", ")", "+", "\".preprocessing-time\"", ")", ".", "begin", "(", ")", ";", "FiniteProgress", "progress", "=", "LOG", ".", "isVerbose", "(", ")", "?", "new", "FiniteProgress", "(", "this", ".", "getClass", "(", ")", ".", "getName", "(", ")", ",", "relation", ".", "size", "(", ")", ",", "LOG", ")", ":", "null", ";", "for", "(", "DBIDIter", "iditer", "=", "relation", ".", "iterDBIDs", "(", ")", ";", "iditer", ".", "valid", "(", ")", ";", "iditer", ".", "advance", "(", ")", ")", "{", "DoubleDBIDList", "ref", "=", "knnq", ".", "getKNNForDBID", "(", "iditer", ",", "settings", ".", "k", ")", ";", "storage", ".", "put", "(", "iditer", ",", "computeLocalModel", "(", "iditer", ",", "ref", ",", "relation", ")", ")", ";", "LOG", ".", "incrementProcessed", "(", "progress", ")", ";", "}", "LOG", ".", "ensureCompleted", "(", "progress", ")", ";", "LOG", ".", "statistics", "(", "time", ".", "end", "(", ")", ")", ";", "return", "new", "Instance", "(", "relation", ".", "getDBIDs", "(", ")", ",", "storage", ")", ";", "}" ]

[ "Full", "instantiation", "method", "." ]

[ "public", "boolean", "hasRoleForResource", "(", "CmsObject", "cms", ",", "CmsRole", "role", ",", "String", "resourceName", ")", "{", "CmsResource", "resource", ";", "try", "{", "resource", "=", "cms", ".", "readResource", "(", "resourceName", ",", "CmsResourceFilter", ".", "ALL", ")", ";", "}", "catch", "(", "CmsException", "e", ")", "{", "// ignore", "return", "false", ";", "}", "return", "m_securityManager", ".", "hasRoleForResource", "(", "cms", ".", "getRequestContext", "(", ")", ",", "cms", ".", "getRequestContext", "(", ")", ".", "getCurrentUser", "(", ")", ",", "role", ",", "resource", ")", ";", "}" ]

[ "Checks", "if", "the", "given", "context", "user", "has", "the", "given", "role", "for", "the", "given", "resource", ".", "<p", ">" ]

[ "public", "void", "getBytes", "(", "int", "index", ",", "Slice", "destination", ",", "int", "destinationIndex", ",", "int", "length", ")", "{", "destination", ".", "setBytes", "(", "destinationIndex", ",", "this", ",", "index", ",", "length", ")", ";", "}" ]

[ "Transfers", "portion", "of", "data", "from", "this", "slice", "into", "the", "specified", "destination", "starting", "at", "the", "specified", "absolute", "{", "@code", "index", "}", "." ]

[ "public", "static", "List", "<", "HttpCode", ">", "getHttpStatusCodes", "(", "List", "<", "BinaryAnnotation", ">", "binaryAnnotations", ")", "{", "if", "(", "binaryAnnotations", "==", "null", ")", "{", "return", "Collections", ".", "emptyList", "(", ")", ";", "}", "List", "<", "HttpCode", ">", "httpCodes", "=", "new", "ArrayList", "<>", "(", ")", ";", "for", "(", "BinaryAnnotation", "binaryAnnotation", ":", "binaryAnnotations", ")", "{", "if", "(", "Constants", ".", "ZIPKIN_BIN_ANNOTATION_HTTP_STATUS_CODE", ".", "equals", "(", "binaryAnnotation", ".", "getKey", "(", ")", ")", "&&", "binaryAnnotation", ".", "getValue", "(", ")", "!=", "null", ")", "{", "String", "strHttpCode", "=", "binaryAnnotation", ".", "getValue", "(", ")", ";", "Integer", "httpCode", "=", "toInt", "(", "strHttpCode", ".", "trim", "(", ")", ")", ";", "if", "(", "httpCode", "!=", "null", ")", "{", "String", "description", "=", "EnglishReasonPhraseCatalog", ".", "INSTANCE", ".", "getReason", "(", "httpCode", ",", "Locale", ".", "ENGLISH", ")", ";", "httpCodes", ".", "add", "(", "new", "HttpCode", "(", "httpCode", ",", "description", ")", ")", ";", "}", "}", "}", "return", "httpCodes", ";", "}" ]

[ "Method", "returns", "list", "of", "http", "status", "codes", "." ]

[ "void", "performStreamingRepair", "(", ")", "{", "InetAddress", "local", "=", "FBUtilities", ".", "getBroadcastAddress", "(", ")", ";", "// We can take anyone of the node as source or destination, however if one is localhost, we put at source to avoid a forwarding", "InetAddress", "src", "=", "r2", ".", "endpoint", ".", "equals", "(", "local", ")", "?", "r2", ".", "endpoint", ":", "r1", ".", "endpoint", ";", "InetAddress", "dst", "=", "r2", ".", "endpoint", ".", "equals", "(", "local", ")", "?", "r1", ".", "endpoint", ":", "r2", ".", "endpoint", ";", "SyncRequest", "request", "=", "new", "SyncRequest", "(", "desc", ",", "local", ",", "src", ",", "dst", ",", "differences", ")", ";", "StreamingRepairTask", "task", "=", "new", "StreamingRepairTask", "(", "desc", ",", "request", ")", ";", "task", ".", "run", "(", ")", ";", "}" ]

[ "Starts", "sending", "/", "receiving", "our", "list", "of", "differences", "to", "/", "from", "the", "remote", "endpoint", ":", "creates", "a", "callback", "that", "will", "be", "called", "out", "of", "band", "once", "the", "streams", "complete", "." ]

[ "@", "Override", "public", "int", "countByG_A_C", "(", "long", "groupId", ",", "boolean", "active", ",", "long", "commerceCountryId", ")", "{", "FinderPath", "finderPath", "=", "FINDER_PATH_COUNT_BY_G_A_C", ";", "Object", "[", "]", "finderArgs", "=", "new", "Object", "[", "]", "{", "groupId", ",", "active", ",", "commerceCountryId", "}", ";", "Long", "count", "=", "(", "Long", ")", "finderCache", ".", "getResult", "(", "finderPath", ",", "finderArgs", ",", "this", ")", ";", "if", "(", "count", "==", "null", ")", "{", "StringBundler", "query", "=", "new", "StringBundler", "(", "4", ")", ";", "query", ".", "append", "(", "_SQL_COUNT_COMMERCEWAREHOUSE_WHERE", ")", ";", "query", ".", "append", "(", "_FINDER_COLUMN_G_A_C_GROUPID_2", ")", ";", "query", ".", "append", "(", "_FINDER_COLUMN_G_A_C_ACTIVE_2", ")", ";", "query", ".", "append", "(", "_FINDER_COLUMN_G_A_C_COMMERCECOUNTRYID_2", ")", ";", "String", "sql", "=", "query", ".", "toString", "(", ")", ";", "Session", "session", "=", "null", ";", "try", "{", "session", "=", "openSession", "(", ")", ";", "Query", "q", "=", "session", ".", "createQuery", "(", "sql", ")", ";", "QueryPos", "qPos", "=", "QueryPos", ".", "getInstance", "(", "q", ")", ";", "qPos", ".", "add", "(", "groupId", ")", ";", "qPos", ".", "add", "(", "active", ")", ";", "qPos", ".", "add", "(", "commerceCountryId", ")", ";", "count", "=", "(", "Long", ")", "q", ".", "uniqueResult", "(", ")", ";", "finderCache", ".", "putResult", "(", "finderPath", ",", "finderArgs", ",", "count", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "finderCache", ".", "removeResult", "(", "finderPath", ",", "finderArgs", ")", ";", "throw", "processException", "(", "e", ")", ";", "}", "finally", "{", "closeSession", "(", "session", ")", ";", "}", "}", "return", "count", ".", "intValue", "(", ")", ";", "}" ]

[ "Returns", "the", "number", "of", "commerce", "warehouses", "where", "groupId", "=", "&#63", ";", "and", "active", "=", "&#63", ";", "and", "commerceCountryId", "=", "&#63", ";", "." ]

[ "public", "static", "HazardCurve", "createHazardCurveFromSurvivalProbabilities", "(", "String", "name", ",", "LocalDate", "referenceDate", ",", "double", "[", "]", "times", ",", "double", "[", "]", "givenSurvivalProbabilities", ",", "boolean", "[", "]", "isParameter", ",", "InterpolationMethod", "interpolationMethod", ",", "ExtrapolationMethod", "extrapolationMethod", ",", "InterpolationEntity", "interpolationEntity", ")", "{", "//We check that all input survival probabilities are in the range [0,1]", "for", "(", "int", "i", "=", "0", ";", "i", "<", "givenSurvivalProbabilities", ".", "length", ";", "i", "++", ")", "{", "if", "(", "givenSurvivalProbabilities", "[", "i", "]", "<", "0", "||", "givenSurvivalProbabilities", "[", "i", "]", ">", "1", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Survival Probabilities must be between 0 and 1\"", ")", ";", "}", "}", "HazardCurve", "survivalProbabilities", "=", "new", "HazardCurve", "(", "name", ",", "referenceDate", ",", "interpolationMethod", ",", "extrapolationMethod", ",", "interpolationEntity", ")", ";", "for", "(", "int", "timeIndex", "=", "0", ";", "timeIndex", "<", "times", ".", "length", ";", "timeIndex", "++", ")", "{", "survivalProbabilities", ".", "addSurvivalProbability", "(", "times", "[", "timeIndex", "]", ",", "givenSurvivalProbabilities", "[", "timeIndex", "]", ",", "isParameter", "!=", "null", "&&", "isParameter", "[", "timeIndex", "]", ")", ";", "}", "return", "survivalProbabilities", ";", "}" ]

[ "Create", "a", "hazard", "curve", "from", "given", "times", "and", "given", "survival", "probabilities", "using", "given", "interpolation", "and", "extrapolation", "methods", "." ]

[ "public", "static", "MetricsConnection", "connection_administratorRole", "(", "LibertyServer", "server", ")", "{", "return", "new", "MetricsConnection", "(", "server", ",", "METRICS_ENDPOINT", ")", ".", "secure", "(", "true", ")", ".", "header", "(", "\"Authorization\"", ",", "\"Basic \"", "+", "Base64Coder", ".", "base64Encode", "(", "ADMINISTRATOR_USERNAME", "+", "\":\"", "+", "ADMINISTRATOR_PASSWORD", ")", ")", ";", "}" ]

[ "Creates", "a", "connection", "for", "private", "(", "authorized", ")", "docs", "endpoint", "using", "HTTPS", "and", "the", "Administrator", "role" ]

[ "protected", "final", "void", "firePropertyParentChanged", "(", "N", "oldParent", ",", "N", "newParent", ")", "{", "firePropertyParentChanged", "(", "new", "TreeNodeParentChangedEvent", "(", "toN", "(", ")", ",", "oldParent", ",", "newParent", ")", ")", ";", "}" ]

[ "Fire", "the", "event", "for", "the", "changes", "node", "parents", "." ]

[ "public", "static", "JsonPullParser", "newParser", "(", "InputStream", "is", ",", "Charset", "charset", ")", "{", "if", "(", "is", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"'is' must not be null.\"", ")", ";", "}", "final", "Reader", "reader", "=", "new", "InputStreamReader", "(", "is", ",", "(", "charset", "==", "null", ")", "?", "DEFAULT_CHARSET", ":", "charset", ")", ";", "return", "newParser", "(", "reader", ")", ";", "}" ]

[ "Creates", "a", "new", "parser", "using", "the", "given", "InputStream", "as", "its", "{", "@code", "JSON", "}", "feed", "." ]

[ "public", "static", "Double", "evaluateAsNumber", "(", "Node", "node", ",", "String", "xPathExpression", ",", "NamespaceContext", "nsContext", ")", "{", "return", "(", "Double", ")", "evaluateExpression", "(", "node", ",", "xPathExpression", ",", "nsContext", ",", "XPathConstants", ".", "NUMBER", ")", ";", "}" ]

[ "Evaluate", "XPath", "expression", "with", "result", "type", "Number", "." ]

[ "public", "static", "long", "estimateMapCost", "(", "long", "size", ",", "boolean", "ordered", ",", "boolean", "usesCachedQueryableEntries", ")", "{", "long", "mapCost", ";", "if", "(", "ordered", ")", "{", "mapCost", "=", "BASE_CONCURRENT_SKIP_LIST_MAP_COST", "+", "size", "*", "CONCURRENT_SKIP_LIST_MAP_ENTRY_COST", ";", "}", "else", "{", "mapCost", "=", "BASE_CONCURRENT_HASH_MAP_COST", "+", "size", "*", "CONCURRENT_HASH_MAP_ENTRY_COST", ";", "}", "long", "queryableEntriesCost", ";", "if", "(", "usesCachedQueryableEntries", ")", "{", "queryableEntriesCost", "=", "size", "*", "CACHED_QUERYABLE_ENTRY_COST", ";", "}", "else", "{", "queryableEntriesCost", "=", "size", "*", "QUERY_ENTRY_COST", ";", "}", "return", "mapCost", "+", "queryableEntriesCost", ";", "}" ]

[ "Estimates", "the", "on", "-", "heap", "memory", "cost", "of", "a", "map", "backing", "an", "index", "." ]

[ "protected", "void", "executeTx", "(", "final", "TxRunnable", "r", ",", "final", "TxRunnable", "errorHandler", ")", "throws", "Exception", "{", "Transaction", "transaction", "=", "beginTransaction", "(", ")", ";", "configureTransDefault", "(", "transaction", ")", ";", "processTransactionError", "(", "transaction", ",", "t", "->", "{", "try", "{", "r", ".", "run", "(", "t", ")", ";", "t", ".", "commit", "(", ")", ";", "}", "catch", "(", "Throwable", "e", ")", "{", "t", ".", "rollback", "(", "e", ")", ";", "throw", "e", ";", "}", "finally", "{", "t", ".", "end", "(", ")", ";", "}", "return", "null", ";", "}", ",", "errorHandler", "!=", "null", "?", "(", "TxCallable", ")", "t", "->", "{", "errorHandler", ".", "run", "(", "t", ")", ";", "return", "null", ";", "}", ":", "null", ")", ";", "}" ]

[ "<p", ">", "executeTx", ".", "<", "/", "p", ">" ]

[ "public", "static", "void", "bufferedToPlanar_U8", "(", "BufferedImage", "src", ",", "Planar", "<", "GrayU8", ">", "dst", ")", "{", "final", "int", "width", "=", "src", ".", "getWidth", "(", ")", ";", "final", "int", "height", "=", "src", ".", "getHeight", "(", ")", ";", "if", "(", "dst", ".", "getNumBands", "(", ")", "==", "3", ")", "{", "byte", "[", "]", "band1", "=", "dst", ".", "getBand", "(", "0", ")", ".", "data", ";", "byte", "[", "]", "band2", "=", "dst", ".", "getBand", "(", "1", ")", ".", "data", ";", "byte", "[", "]", "band3", "=", "dst", ".", "getBand", "(", "2", ")", ".", "data", ";", "//CONCURRENT_BELOW BoofConcurrency.loopFor(0, height, y -> {", "for", "(", "int", "y", "=", "0", ";", "y", "<", "height", ";", "y", "++", ")", "{", "int", "index", "=", "dst", ".", "startIndex", "+", "y", "*", "dst", ".", "stride", ";", "for", "(", "int", "x", "=", "0", ";", "x", "<", "width", ";", "x", "++", ",", "index", "++", ")", "{", "int", "argb", "=", "src", ".", "getRGB", "(", "x", ",", "y", ")", ";", "band1", "[", "index", "]", "=", "(", "byte", ")", "(", "argb", ">>>", "16", ")", ";", "band2", "[", "index", "]", "=", "(", "byte", ")", "(", "argb", ">>>", "8", ")", ";", "band3", "[", "index", "]", "=", "(", "byte", ")", "argb", ";", "}", "}", "//CONCURRENT_ABOVE });", "}", "else", "{", "bufferedToGray", "(", "src", ",", "dst", ".", "getBand", "(", "0", ")", ".", "data", ",", "dst", ".", "startIndex", ",", "dst", ".", "stride", ")", ";", "GrayU8", "band1", "=", "dst", ".", "getBand", "(", "0", ")", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<", "dst", ".", "getNumBands", "(", ")", ";", "i", "++", ")", "{", "dst", ".", "getBand", "(", "i", ")", ".", "setTo", "(", "band1", ")", ";", "}", "}", "}" ]

[ "<p", ">", "Converts", "a", "buffered", "image", "into", "an", "planar", "image", "using", "the", "BufferedImage", "s", "RGB", "interface", ".", "<", "/", "p", ">", "<p", ">", "This", "is", "much", "slower", "than", "working", "directly", "with", "the", "BufferedImage", "s", "internal", "raster", "and", "should", "be", "avoided", "if", "possible", ".", "<", "/", "p", ">" ]

[ "@", "Nullable", "public", "static", "CascadingStyleSheet", "readFromFile", "(", "@", "Nonnull", "final", "File", "aFile", ",", "@", "Nonnull", "final", "CSSReaderSettings", "aSettings", ")", "{", "return", "readFromStream", "(", "new", "FileSystemResource", "(", "aFile", ")", ",", "aSettings", ")", ";", "}" ]

[ "Read", "the", "CSS", "from", "the", "passed", "File", "." ]

[ "public", "static", "void", "extractDiag", "(", "DMatrixSparseCSC", "src", ",", "DMatrixRMaj", "dst", ")", "{", "int", "N", "=", "Math", ".", "min", "(", "src", ".", "numRows", ",", "src", ".", "numCols", ")", ";", "if", "(", "dst", ".", "getNumElements", "(", ")", "!=", "N", "||", "!", "(", "dst", ".", "numRows", "==", "1", "||", "dst", ".", "numCols", "==", "1", ")", ")", "{", "dst", ".", "reshape", "(", "N", ",", "1", ")", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "N", ";", "i", "++", ")", "{", "dst", ".", "data", "[", "i", "]", "=", "src", ".", "unsafe_get", "(", "i", ",", "i", ")", ";", "}", "}" ]

[ "<p", ">", "Extracts", "the", "diagonal", "elements", "src", "write", "it", "to", "the", "dst", "vector", ".", "dst", "can", "either", "be", "a", "row", "or", "column", "vector", ".", "<p", ">" ]

[ "private", "Iterable", "<", "Cursor", ">", "onFindAll", "(", "EnvKelp", "envKelp", ",", "Iterable", "<", "RowCursor", ">", "rowIter", ")", "{", "if", "(", "rowIter", "==", "null", ")", "{", "return", "null", ";", "}", "return", "new", "CursorIterable", "(", "envKelp", ",", "rowIter", ",", "_results", ")", ";", "}" ]

[ "/", "*", "private", "class", "FindAllResult", "extends", "Result", ".", "Wrapper<Iterable<RowCursor", ">", "Iterable<Cursor", ">>", "{", "private", "EnvKelp", "_envKelp", ";" ]

[ "public", "static", "int", "readHeader", "(", "ByteBuffer", "bytes", ",", "int", "dataFormat", ",", "Authenticate", "authenticate", ")", "throws", "IOException", "{", "assert", "bytes", "!=", "null", "&&", "bytes", ".", "position", "(", ")", "==", "0", ";", "byte", "magic1", "=", "bytes", ".", "get", "(", "2", ")", ";", "byte", "magic2", "=", "bytes", ".", "get", "(", "3", ")", ";", "if", "(", "magic1", "!=", "MAGIC1", "||", "magic2", "!=", "MAGIC2", ")", "{", "throw", "new", "IOException", "(", "MAGIC_NUMBER_AUTHENTICATION_FAILED_", ")", ";", "}", "byte", "isBigEndian", "=", "bytes", ".", "get", "(", "8", ")", ";", "byte", "charsetFamily", "=", "bytes", ".", "get", "(", "9", ")", ";", "byte", "sizeofUChar", "=", "bytes", ".", "get", "(", "10", ")", ";", "if", "(", "isBigEndian", "<", "0", "||", "1", "<", "isBigEndian", "||", "charsetFamily", "!=", "CHAR_SET_", "||", "sizeofUChar", "!=", "CHAR_SIZE_", ")", "{", "throw", "new", "IOException", "(", "HEADER_AUTHENTICATION_FAILED_", ")", ";", "}", "bytes", ".", "order", "(", "isBigEndian", "!=", "0", "?", "ByteOrder", ".", "BIG_ENDIAN", ":", "ByteOrder", ".", "LITTLE_ENDIAN", ")", ";", "int", "headerSize", "=", "bytes", ".", "getChar", "(", "0", ")", ";", "int", "sizeofUDataInfo", "=", "bytes", ".", "getChar", "(", "4", ")", ";", "if", "(", "sizeofUDataInfo", "<", "20", "||", "headerSize", "<", "(", "sizeofUDataInfo", "+", "4", ")", ")", "{", "throw", "new", "IOException", "(", "\"Internal Error: Header size error\"", ")", ";", "}", "// TODO: Change Authenticate to take int major, int minor, int milli, int micro", "// to avoid array allocation.", "byte", "[", "]", "formatVersion", "=", "new", "byte", "[", "]", "{", "bytes", ".", "get", "(", "16", ")", ",", "bytes", ".", "get", "(", "17", ")", ",", "bytes", ".", "get", "(", "18", ")", ",", "bytes", ".", "get", "(", "19", ")", "}", ";", "if", "(", "bytes", ".", "get", "(", "12", ")", "!=", "(", "byte", ")", "(", "dataFormat", ">>", "24", ")", "||", "bytes", ".", "get", "(", "13", ")", "!=", "(", "byte", ")", "(", "dataFormat", ">>", "16", ")", "||", "bytes", ".", "get", "(", "14", ")", "!=", "(", "byte", ")", "(", "dataFormat", ">>", "8", ")", "||", "bytes", ".", "get", "(", "15", ")", "!=", "(", "byte", ")", "dataFormat", "||", "(", "authenticate", "!=", "null", "&&", "!", "authenticate", ".", "isDataVersionAcceptable", "(", "formatVersion", ")", ")", ")", "{", "throw", "new", "IOException", "(", "HEADER_AUTHENTICATION_FAILED_", "+", "String", ".", "format", "(", "\"; data format %02x%02x%02x%02x, format version %d.%d.%d.%d\"", ",", "bytes", ".", "get", "(", "12", ")", ",", "bytes", ".", "get", "(", "13", ")", ",", "bytes", ".", "get", "(", "14", ")", ",", "bytes", ".", "get", "(", "15", ")", ",", "formatVersion", "[", "0", "]", "&", "0xff", ",", "formatVersion", "[", "1", "]", "&", "0xff", ",", "formatVersion", "[", "2", "]", "&", "0xff", ",", "formatVersion", "[", "3", "]", "&", "0xff", ")", ")", ";", "}", "bytes", ".", "position", "(", "headerSize", ")", ";", "return", "// dataVersion", "(", "bytes", ".", "get", "(", "20", ")", "<<", "24", ")", "|", "(", "(", "bytes", ".", "get", "(", "21", ")", "&", "0xff", ")", "<<", "16", ")", "|", "(", "(", "bytes", ".", "get", "(", "22", ")", "&", "0xff", ")", "<<", "8", ")", "|", "(", "bytes", ".", "get", "(", "23", ")", "&", "0xff", ")", ";", "}" ]

[ "Reads", "an", "ICU", "data", "header", "checks", "the", "data", "format", "and", "returns", "the", "data", "version", "." ]

[ "public", "<", "E", "extends", "Exception", ">", "boolean", "allMatch", "(", "Try", ".", "FloatPredicate", "<", "E", ">", "filter", ")", "throws", "E", "{", "return", "allMatch", "(", "0", ",", "size", "(", ")", ",", "filter", ")", ";", "}" ]

[ "Returns", "whether", "all", "elements", "of", "this", "List", "match", "the", "provided", "predicate", "." ]

[ "public", "static", "String", "toJsonString", "(", "Collection", "<", "Attribute", ">", "attributeCollection", ",", "ObjectMapper", "objectMapper", ")", "throws", "JsonProcessingException", "{", "return", "objectMapper", ".", "writeValueAsString", "(", "toObject", "(", "attributeCollection", ")", ")", ";", "}" ]

[ "Re", "-", "expands", "a", "flattened", "json", "representation", "from", "a", "collection", "of", "attributes", "back", "into", "a", "raw", "nested", "json", "string", "." ]

[ "public", "static", "byte", "[", "]", "decodeFromFile", "(", "String", "filename", ")", "throws", "java", ".", "io", ".", "IOException", "{", "byte", "[", "]", "decodedData", "=", "null", ";", "Base64", ".", "InputStream", "bis", "=", "null", ";", "try", "{", "// Set up some useful variables", "Path", "file", "=", "Paths", ".", "get", "(", "filename", ")", ";", "byte", "[", "]", "buffer", ";", "int", "length", "=", "0", ";", "int", "numBytes", ";", "// Check for size of file", "if", "(", "Files", ".", "size", "(", "file", ")", ">", "Integer", ".", "MAX_VALUE", ")", "{", "throw", "new", "java", ".", "io", ".", "IOException", "(", "\"File is too big for this convenience method (\"", "+", "Files", ".", "size", "(", "file", ")", "+", "\" bytes).\"", ")", ";", "}", "// end if: file too big for int index", "buffer", "=", "new", "byte", "[", "(", "int", ")", "Files", ".", "size", "(", "file", ")", "]", ";", "// Open a stream", "bis", "=", "new", "Base64", ".", "InputStream", "(", "new", "java", ".", "io", ".", "BufferedInputStream", "(", "Files", ".", "newInputStream", "(", "file", ")", ")", ",", "Base64", ".", "DECODE", ")", ";", "// Read until done", "while", "(", "(", "numBytes", "=", "bis", ".", "read", "(", "buffer", ",", "length", ",", "4096", ")", ")", ">=", "0", ")", "{", "length", "+=", "numBytes", ";", "}", "// end while", "// Save in a variable to return", "decodedData", "=", "new", "byte", "[", "length", "]", ";", "System", ".", "arraycopy", "(", "buffer", ",", "0", ",", "decodedData", ",", "0", ",", "length", ")", ";", "}", "// end try", "catch", "(", "java", ".", "io", ".", "IOException", "e", ")", "{", "throw", "e", ";", "// Catch and release to execute finally{}", "}", "// end catch: java.io.IOException", "finally", "{", "try", "{", "bis", ".", "close", "(", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "}", "}", "// end finally", "return", "decodedData", ";", "}" ]

[ "Convenience", "method", "for", "reading", "a", "base64", "-", "encoded", "file", "and", "decoding", "it", "." ]

[ "@", "NullSafe", "public", "static", "boolean", "isAnnotationPresent", "(", "Class", "<", "?", "extends", "Annotation", ">", "annotation", ",", "AnnotatedElement", "...", "members", ")", "{", "return", "stream", "(", "ArrayUtils", ".", "nullSafeArray", "(", "members", ",", "AnnotatedElement", ".", "class", ")", ")", ".", "anyMatch", "(", "member", "->", "member", "!=", "null", "&&", "member", ".", "isAnnotationPresent", "(", "annotation", ")", ")", ";", "}" ]

[ "Determines", "whether", "the", "specified", "Annotation", "meta", "-", "data", "is", "present", "on", "the", "given", "annotated", "members", "such", "as", "fields", "and", "methods", "." ]

[ "public", "static", "void", "copy", "(", "Reader", "reader", ",", "Writer", "writer", ")", "throws", "IOException", "{", "copy", "(", "reader", ",", "writer", ",", "false", ")", ";", "}" ]

[ "Writes", "all", "the", "contents", "of", "a", "Reader", "to", "a", "Writer", "." ]

[ "public", "int", "removeShapesWithExclusion", "(", "String", "database", ",", "String", "table", ",", "GoogleMapShapeType", "excludedType", ")", "{", "Set", "<", "GoogleMapShapeType", ">", "excludedTypes", "=", "new", "HashSet", "<>", "(", ")", ";", "excludedTypes", ".", "add", "(", "excludedType", ")", ";", "return", "removeShapesWithExclusions", "(", "database", ",", "table", ",", "excludedTypes", ")", ";", "}" ]

[ "Remove", "all", "map", "shapes", "in", "the", "database", "and", "table", "from", "the", "map", "excluding", "shapes", "with", "the", "excluded", "type" ]

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

[ "Gets", "the", "detailed", "information", "about", "a", "linked", "server", "of", "a", "redis", "cache", "(", "requires", "Premium", "SKU", ")", "." ]

[ "public", "UserSignature", "updateSignature", "(", "String", "accountId", ",", "String", "userId", ",", "String", "signatureId", ",", "UserSignatureDefinition", "userSignatureDefinition", ",", "UsersApi", ".", "UpdateSignatureOptions", "options", ")", "throws", "ApiException", "{", "Object", "localVarPostBody", "=", "userSignatureDefinition", ";", "// verify the required parameter 'accountId' is set", "if", "(", "accountId", "==", "null", ")", "{", "throw", "new", "ApiException", "(", "400", ",", "\"Missing the required parameter 'accountId' when calling updateSignature\"", ")", ";", "}", "// verify the required parameter 'userId' is set", "if", "(", "userId", "==", "null", ")", "{", "throw", "new", "ApiException", "(", "400", ",", "\"Missing the required parameter 'userId' when calling updateSignature\"", ")", ";", "}", "// verify the required parameter 'signatureId' is set", "if", "(", "signatureId", "==", "null", ")", "{", "throw", "new", "ApiException", "(", "400", ",", "\"Missing the required parameter 'signatureId' when calling updateSignature\"", ")", ";", "}", "// create path and map variables", "String", "localVarPath", "=", "\"/v2/accounts/{accountId}/users/{userId}/signatures/{signatureId}\"", ".", "replaceAll", "(", "\"\\\\{format\\\\}\"", ",", "\"json\"", ")", ".", "replaceAll", "(", "\"\\\\{\"", "+", "\"accountId\"", "+", "\"\\\\}\"", ",", "apiClient", ".", "escapeString", "(", "accountId", ".", "toString", "(", ")", ")", ")", ".", "replaceAll", "(", "\"\\\\{\"", "+", "\"userId\"", "+", "\"\\\\}\"", ",", "apiClient", ".", "escapeString", "(", "userId", ".", "toString", "(", ")", ")", ")", ".", "replaceAll", "(", "\"\\\\{\"", "+", "\"signatureId\"", "+", "\"\\\\}\"", ",", "apiClient", ".", "escapeString", "(", "signatureId", ".", "toString", "(", ")", ")", ")", ";", "// query params", "java", ".", "util", ".", "List", "<", "Pair", ">", "localVarQueryParams", "=", "new", "java", ".", "util", ".", "ArrayList", "<", "Pair", ">", "(", ")", ";", "java", ".", "util", ".", "Map", "<", "String", ",", "String", ">", "localVarHeaderParams", "=", "new", "java", ".", "util", ".", "HashMap", "<", "String", ",", "String", ">", "(", ")", ";", "java", ".", "util", ".", "Map", "<", "String", ",", "Object", ">", "localVarFormParams", "=", "new", "java", ".", "util", ".", "HashMap", "<", "String", ",", "Object", ">", "(", ")", ";", "if", "(", "options", "!=", "null", ")", "{", "localVarQueryParams", ".", "addAll", "(", "apiClient", ".", "parameterToPairs", "(", "\"\"", ",", "\"close_existing_signature\"", ",", "options", ".", "closeExistingSignature", ")", ")", ";", "}", "final", "String", "[", "]", "localVarAccepts", "=", "{", "\"application/json\"", "}", ";", "final", "String", "localVarAccept", "=", "apiClient", ".", "selectHeaderAccept", "(", "localVarAccepts", ")", ";", "final", "String", "[", "]", "localVarContentTypes", "=", "{", "}", ";", "final", "String", "localVarContentType", "=", "apiClient", ".", "selectHeaderContentType", "(", "localVarContentTypes", ")", ";", "String", "[", "]", "localVarAuthNames", "=", "new", "String", "[", "]", "{", "\"docusignAccessCode\"", "}", ";", "//{ };", "GenericType", "<", "UserSignature", ">", "localVarReturnType", "=", "new", "GenericType", "<", "UserSignature", ">", "(", ")", "{", "}", ";", "return", "apiClient", ".", "invokeAPI", "(", "localVarPath", ",", "\"PUT\"", ",", "localVarQueryParams", ",", "localVarPostBody", ",", "localVarHeaderParams", ",", "localVarFormParams", ",", "localVarAccept", ",", "localVarContentType", ",", "localVarAuthNames", ",", "localVarReturnType", ")", ";", "}" ]

[ "Updates", "the", "user", "signature", "for", "a", "specified", "user", ".", "Creates", "or", "updates", "the", "signature", "font", "and", "initials", "for", "the", "specified", "user", ".", "When", "creating", "a", "signature", "you", "use", "this", "resource", "to", "create", "the", "signature", "name", "and", "then", "add", "the", "signature", "and", "initials", "images", "into", "the", "signature", ".", "######", "Note", ":", "This", "will", "also", "create", "a", "default", "signature", "for", "the", "user", "when", "one", "does", "not", "exist", ".", "The", "userId", "property", "specified", "in", "the", "endpoint", "must", "match", "the", "authenticated", "user&#39", ";", "s", "user", "ID", "and", "the", "user", "must", "be", "a", "member", "of", "the", "account", ".", "The", "&#x60", ";", "signatureId&#x60", ";", "parameter", "accepts", "a", "signature", "ID", "or", "a", "signature", "name", ".", "DocuSign", "recommends", "you", "use", "signature", "ID", "(", "&#x60", ";", "signatureId&#x60", ";", ")", "since", "some", "names", "contain", "characters", "that", "do", "not", "properly", "encode", "into", "a", "URL", ".", "If", "you", "use", "the", "user", "name", "it", "is", "likely", "that", "the", "name", "includes", "spaces", ".", "In", "that", "case", "URL", "encode", "the", "name", "before", "using", "it", "in", "the", "endpoint", ".", "For", "example", "encode", "\\", "&quot", ";", "Bob", "Smith", "\\", "&quot", ";", "as", "\\", "&quot", ";", "Bob%20Smith", "\\", "&quot", ";", "." ]

[ "protected", "String", "checkValidAliasPath", "(", "String", "path", ",", "Locale", "locale", ")", "{", "if", "(", "org", ".", "opencms", ".", "db", ".", "CmsAlias", ".", "ALIAS_PATTERN", ".", "matcher", "(", "path", ")", ".", "matches", "(", ")", ")", "{", "return", "null", ";", "}", "else", "{", "return", "Messages", ".", "get", "(", ")", ".", "getBundle", "(", "locale", ")", ".", "key", "(", "Messages", ".", "ERR_ALIAS_INVALID_PATH_0", ")", ";", "}", "}" ]

[ "Checks", "whether", "a", "given", "string", "is", "a", "valid", "alias", "path", ".", "<p", ">" ]

[ "public", "ByteVector", "putUTF8", "(", "final", "String", "stringValue", ")", "{", "int", "charLength", "=", "stringValue", ".", "length", "(", ")", ";", "if", "(", "charLength", ">", "65535", ")", "{", "throw", "new", "IllegalArgumentException", "(", ")", ";", "}", "int", "currentLength", "=", "length", ";", "if", "(", "currentLength", "+", "2", "+", "charLength", ">", "data", ".", "length", ")", "{", "enlarge", "(", "2", "+", "charLength", ")", ";", "}", "byte", "[", "]", "currentData", "=", "data", ";", "// Optimistic algorithm: instead of computing the byte length and then serializing the string", "// (which requires two loops), we assume the byte length is equal to char length (which is the", "// most frequent case), and we start serializing the string right away. During the", "// serialization, if we find that this assumption is wrong, we continue with the general method.", "currentData", "[", "currentLength", "++", "]", "=", "(", "byte", ")", "(", "charLength", ">>>", "8", ")", ";", "currentData", "[", "currentLength", "++", "]", "=", "(", "byte", ")", "charLength", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "charLength", ";", "++", "i", ")", "{", "char", "charValue", "=", "stringValue", ".", "charAt", "(", "i", ")", ";", "if", "(", "charValue", ">=", "'", "'", "&&", "charValue", "<=", "'", "'", ")", "{", "currentData", "[", "currentLength", "++", "]", "=", "(", "byte", ")", "charValue", ";", "}", "else", "{", "length", "=", "currentLength", ";", "return", "encodeUTF8", "(", "stringValue", ",", "i", ",", "65535", ")", ";", "}", "}", "length", "=", "currentLength", ";", "return", "this", ";", "}" ]

[ "Puts", "an", "UTF8", "string", "into", "this", "byte", "vector", ".", "The", "byte", "vector", "is", "automatically", "enlarged", "if", "necessary", "." ]

[ "public", "static", "<", "N", "extends", "Number", "&", "Comparable", "<", "?", "super", "N", ">", ">", "Rectangle", "closedOpen", "(", "final", "N", "lower", ",", "final", "N", "upper", ")", "{", "checkNotNull", "(", "lower", ")", ";", "checkNotNull", "(", "upper", ")", ";", "return", "range", "(", "Range", ".", "closedOpen", "(", "lower", ",", "upper", ")", ")", ";", "}" ]

[ "Create", "and", "return", "a", "new", "rectangle", "geometry", "from", "the", "specified", "closed", "open", "range", "<code", ">", "[", "lower", "..", "upper", ")", "<", "/", "code", ">", "." ]

[ "public", "Protocols", "actorFor", "(", "final", "Class", "<", "?", ">", "[", "]", "protocols", ",", "final", "Class", "<", "?", "extends", "Actor", ">", "type", ",", "final", "Object", "...", "parameters", ")", "{", "if", "(", "isTerminated", "(", ")", ")", "{", "throw", "new", "IllegalStateException", "(", "\"vlingo/actors: Stopped.\"", ")", ";", "}", "return", "stage", "(", ")", ".", "actorFor", "(", "protocols", ",", "type", ",", "parameters", ")", ";", "}" ]

[ "Answers", "a", "{" ]

[ "@", "Nullable", "public", "UnixPath", "getParent", "(", ")", "{", "if", "(", "path", ".", "isEmpty", "(", ")", "||", "isRoot", "(", ")", ")", "{", "return", "null", ";", "}", "int", "index", "=", "hasTrailingSeparator", "(", ")", "?", "path", ".", "lastIndexOf", "(", "SEPARATOR", ",", "path", ".", "length", "(", ")", "-", "2", ")", ":", "path", ".", "lastIndexOf", "(", "SEPARATOR", ")", ";", "if", "(", "index", "==", "-", "1", ")", "{", "return", "isAbsolute", "(", ")", "?", "ROOT_PATH", ":", "null", ";", "}", "else", "{", "return", "new", "UnixPath", "(", "permitEmptyComponents", ",", "path", ".", "substring", "(", "0", ",", "index", "+", "1", ")", ")", ";", "}", "}" ]

[ "Returns", "parent", "directory", "(", "including", "trailing", "separator", ")", "or", "{", "@code", "null", "}", "if", "no", "parent", "remains", "." ]

[ "public", "static", "HtmlTree", "A_ID", "(", "HtmlStyle", "styleClass", ",", "String", "id", ",", "Content", "body", ")", "{", "HtmlTree", "htmltree", "=", "A_ID", "(", "id", ",", "body", ")", ";", "if", "(", "styleClass", "!=", "null", ")", "htmltree", ".", "addStyle", "(", "styleClass", ")", ";", "return", "htmltree", ";", "}" ]

[ "Generates", "an", "HTML", "anchor", "tag", "with", "a", "style", "class", "id", "attribute", "and", "a", "body", "." ]

[ "public", "static", "Dataset", "<", "String", ",", "String", ">", "readSVMLightFormat", "(", "String", "filename", ")", "{", "return", "readSVMLightFormat", "(", "filename", ",", "new", "HashIndex", "<", "String", ">", "(", ")", ",", "new", "HashIndex", "<", "String", ">", "(", ")", ")", ";", "}" ]

[ "Constructs", "a", "Dataset", "by", "reading", "in", "a", "file", "in", "SVM", "light", "format", "." ]

[ "public", "static", "ZonalOffset", "ofTotalSeconds", "(", "int", "total", ",", "int", "fraction", ")", "{", "if", "(", "fraction", "!=", "0", ")", "{", "return", "new", "ZonalOffset", "(", "total", ",", "fraction", ")", ";", "}", "else", "if", "(", "total", "==", "0", ")", "{", "return", "UTC", ";", "}", "else", "if", "(", "(", "total", "%", "(", "15", "*", "60", ")", ")", "==", "0", ")", "{", "// Viertelstundenintervall", "Integer", "value", "=", "Integer", ".", "valueOf", "(", "total", ")", ";", "ZonalOffset", "result", "=", "OFFSET_CACHE", ".", "get", "(", "value", ")", ";", "if", "(", "result", "==", "null", ")", "{", "result", "=", "new", "ZonalOffset", "(", "total", ",", "0", ")", ";", "OFFSET_CACHE", ".", "putIfAbsent", "(", "value", ",", "result", ")", ";", "result", "=", "OFFSET_CACHE", ".", "get", "(", "value", ")", ";", "}", "return", "result", ";", "}", "else", "{", "return", "new", "ZonalOffset", "(", "total", ",", "0", ")", ";", "}", "}" ]

[ "/", "*", "[", "deutsch", "]", "<p", ">", "Konstruiert", "eine", "Verschiebung", "der", "lokalen", "Zeit", "relativ", "zur", "UTC", "-", "Zeitzone", "in", "integralen", "oder", "fraktionalen", "Sekunden", ".", "<", "/", "p", ">" ]

[ "private", "void", "initializeScheme", "(", "String", "p_uriSpec", ")", "throws", "MalformedURIException", "{", "int", "uriSpecLen", "=", "p_uriSpec", ".", "length", "(", ")", ";", "int", "index", "=", "0", ";", "String", "scheme", "=", "null", ";", "char", "testChar", "=", "'", "'", ";", "while", "(", "index", "<", "uriSpecLen", ")", "{", "testChar", "=", "p_uriSpec", ".", "charAt", "(", "index", ")", ";", "if", "(", "testChar", "==", "'", "'", "||", "testChar", "==", "'", "'", "||", "testChar", "==", "'", "'", "||", "testChar", "==", "'", "'", ")", "{", "break", ";", "}", "index", "++", ";", "}", "scheme", "=", "p_uriSpec", ".", "substring", "(", "0", ",", "index", ")", ";", "if", "(", "scheme", ".", "length", "(", ")", "==", "0", ")", "{", "throw", "new", "MalformedURIException", "(", "Utils", ".", "messages", ".", "createMessage", "(", "MsgKey", ".", "ER_NO_SCHEME_INURI", ",", "null", ")", ")", ";", "//\"No scheme found in URI.\");", "}", "else", "{", "setScheme", "(", "scheme", ")", ";", "}", "}" ]

[ "Initialize", "the", "scheme", "for", "this", "URI", "from", "a", "URI", "string", "spec", "." ]

[ "public", "void", "writeStyles", "(", "final", "XMLUtil", "xmlUtil", ",", "final", "ZipUTF8Writer", "writer", ")", "throws", "IOException", "{", "this", ".", "logger", ".", "log", "(", "Level", ".", "FINER", ",", "\"Writing odselement: stylesElement to zip file\"", ")", ";", "this", ".", "stylesElement", ".", "write", "(", "xmlUtil", ",", "writer", ")", ";", "}" ]

[ "Write", "the", "styles", "element", "to", "a", "writer", "." ]