Datasets:

---

stojchet

/

base_prediction_dataset

like 0

[ "public", "double", "resolveOverlap", "(", "IAtomContainer", "ac", ",", "IRingSet", "sssr", ")", "{", "Vector", "overlappingAtoms", "=", "new", "Vector", "(", ")", ";", "Vector", "overlappingBonds", "=", "new", "Vector", "(", ")", ";", "logger", ".", "debug", "(", "\"Start of resolveOverlap\"", ")", ";", "double", "overlapScore", "=", "getOverlapScore", "(", "ac", ",", "overlappingAtoms", ",", "overlappingBonds", ")", ";", "if", "(", "overlapScore", ">", "0", ")", "{", "overlapScore", "=", "displace", "(", "ac", ",", "overlappingAtoms", ",", "overlappingBonds", ")", ";", "}", "logger", ".", "debug", "(", "\"overlapScore = \"", "+", "overlapScore", ")", ";", "logger", ".", "debug", "(", "\"End of resolveOverlap\"", ")", ";", "return", "overlapScore", ";", "}" ]

[ "Main", "method", "to", "be", "called", "to", "resolve", "overlap", "situations", "." ]

[ "public", "static", "<", "T", ",", "U", ">", "ToIntBiFunction", "<", "T", ",", "U", ">", "toIntBiFunction", "(", "CheckedToIntBiFunction", "<", "T", ",", "U", ">", "function", ")", "{", "return", "toIntBiFunction", "(", "function", ",", "THROWABLE_TO_RUNTIME_EXCEPTION", ")", ";", "}" ]

[ "Wrap", "a", "{" ]

[ "private", "ParameterBinding", "getBindingFor", "(", "Object", "ebeanQuery", ",", "int", "position", ",", "Parameter", "parameter", ")", "{", "Assert", ".", "notNull", "(", "ebeanQuery", ",", "\"EbeanQueryWrapper must not be null!\"", ")", ";", "Assert", ".", "notNull", "(", "parameter", ",", "\"Parameter must not be null!\"", ")", ";", "if", "(", "parameter", ".", "isNamedParameter", "(", ")", ")", "{", "return", "query", ".", "getBindingFor", "(", "parameter", ".", "getName", "(", ")", ".", "orElseThrow", "(", "(", ")", "->", "new", "IllegalArgumentException", "(", "\"Parameter needs to be named!\"", ")", ")", ")", ";", "}", "try", "{", "return", "query", ".", "getBindingFor", "(", "position", ")", ";", "}", "catch", "(", "IllegalArgumentException", "ex", ")", "{", "// We should actually reject parameters unavailable, but as EclipseLink doesn't implement ….getParameter(int) for\r", "// native queries correctly we need to fall back to an indexed parameter\r", "// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=427892\r", "return", "new", "ParameterBinding", "(", "position", ")", ";", "}", "}" ]

[ "Finds", "the", "{", "@link", "LikeParameterBinding", "}", "to", "be", "applied", "before", "binding", "a", "parameter", "value", "to", "the", "query", "." ]

[ "public", "static", "double", "approximateLowerBoundOnP", "(", "final", "long", "n", ",", "final", "long", "k", ",", "final", "double", "numStdDevs", ")", "{", "checkInputs", "(", "n", ",", "k", ")", ";", "if", "(", "n", "==", "0", ")", "{", "return", "0.0", ";", "}", "// the coin was never flipped, so we know nothing", "else", "if", "(", "k", "==", "0", ")", "{", "return", "0.0", ";", "}", "else", "if", "(", "k", "==", "1", ")", "{", "return", "(", "exactLowerBoundOnPForKequalsOne", "(", "n", ",", "deltaOfNumStdevs", "(", "numStdDevs", ")", ")", ")", ";", "}", "else", "if", "(", "k", "==", "n", ")", "{", "return", "(", "exactLowerBoundOnPForKequalsN", "(", "n", ",", "deltaOfNumStdevs", "(", "numStdDevs", ")", ")", ")", ";", "}", "else", "{", "final", "double", "x", "=", "abramowitzStegunFormula26p5p22", "(", "(", "n", "-", "k", ")", "+", "1", ",", "k", ",", "(", "-", "1.0", "*", "numStdDevs", ")", ")", ";", "return", "(", "1.0", "-", "x", ")", ";", "// which is p", "}", "}" ]

[ "Computes", "lower", "bound", "of", "approximate", "Clopper", "-", "Pearson", "confidence", "interval", "for", "a", "binomial", "proportion", "." ]

[ "public", "boolean", "resetConsumable", "(", "VacuumConsumableStatus", ".", "Names", "consumable", ")", "throws", "CommandExecutionException", "{", "if", "(", "consumable", "==", "null", ")", "throw", "new", "CommandExecutionException", "(", "CommandExecutionException", ".", "Error", ".", "INVALID_PARAMETERS", ")", ";", "JSONArray", "params", "=", "new", "JSONArray", "(", ")", ";", "params", ".", "put", "(", "consumable", ".", "toString", "(", ")", ")", ";", "return", "sendOk", "(", "\"reset_consumable\"", ",", "params", ")", ";", "}" ]

[ "Reset", "a", "vacuums", "consumable", "." ]

[ "public", "static", "int", "nvrtcGetLoweredName", "(", "nvrtcProgram", "prog", ",", "String", "name_expression", ",", "String", "lowered_name", "[", "]", ")", "{", "return", "checkResult", "(", "nvrtcGetLoweredNameNative", "(", "prog", ",", "name_expression", ",", "lowered_name", ")", ")", ";", "}" ]

[ "Extracts", "the", "lowered", "(", "mangled", ")", "name", "for", "a", "__global__", "function", "or", "function", "template", "instantiation", "and", "updates", "*", "lowered_name", "to", "point", "to", "it", ".", "The", "memory", "containing", "the", "name", "is", "released", "when", "the", "NVRTC", "program", "is", "destroyed", "by", "nvrtcDestroyProgram", ".", "<br", ">", "<br", ">", "The", "identical", "name", "expression", "must", "have", "been", "previously", "provided", "to", "nvrtcAddNameExpression", "." ]

[ "public", "void", "eachRow", "(", "String", "sql", ",", "@", "ClosureParams", "(", "value", "=", "SimpleType", ".", "class", ",", "options", "=", "\"java.sql.ResultSetMetaData\"", ")", "Closure", "metaClosure", ",", "@", "ClosureParams", "(", "value", "=", "SimpleType", ".", "class", ",", "options", "=", "\"groovy.sql.GroovyResultSet\"", ")", "Closure", "rowClosure", ")", "throws", "SQLException", "{", "eachRow", "(", "sql", ",", "metaClosure", ",", "0", ",", "0", ",", "rowClosure", ")", ";", "}" ]

[ "Performs", "the", "given", "SQL", "query", "calling", "the", "given", "<code", ">", "rowClosure<", "/", "code", ">", "with", "each", "row", "of", "the", "result", "set", ".", "The", "row", "will", "be", "a", "<code", ">", "GroovyResultSet<", "/", "code", ">", "which", "is", "a", "<code", ">", "ResultSet<", "/", "code", ">", "that", "supports", "accessing", "the", "fields", "using", "property", "style", "notation", "and", "ordinal", "index", "values", ".", "In", "addition", "the", "<code", ">", "metaClosure<", "/", "code", ">", "will", "be", "called", "once", "passing", "in", "the", "<code", ">", "ResultSetMetaData<", "/", "code", ">", "as", "argument", ".", "<p", ">", "Example", "usage", ":", "<pre", ">", "def", "printColNames", "=", "{", "meta", "{", "@code", "-", ">", "}", "(", "1", "..", "meta", ".", "columnCount", ")", ".", "each", "{", "print", "meta", ".", "getColumnLabel", "(", "it", ")", ".", "padRight", "(", "20", ")", "}", "println", "()", "}", "def", "printRow", "=", "{", "row", "{", "@code", "-", ">", "}", "row", ".", "toRowResult", "()", ".", "values", "()", ".", "each", "{", "print", "it", ".", "toString", "()", ".", "padRight", "(", "20", ")", "}", "println", "()", "}", "sql", ".", "eachRow", "(", "select", "*", "from", "PERSON", "printColNames", "printRow", ")", "<", "/", "pre", ">", "<p", ">", "Resource", "handling", "is", "performed", "automatically", "where", "appropriate", "." ]

[ "public", "UpdateIntegrationResponseRequest", "withResponseParameters", "(", "java", ".", "util", ".", "Map", "<", "String", ",", "String", ">", "responseParameters", ")", "{", "setResponseParameters", "(", "responseParameters", ")", ";", "return", "this", ";", "}" ]

[ "<p", ">", "A", "key", "-", "value", "map", "specifying", "response", "parameters", "that", "are", "passed", "to", "the", "method", "response", "from", "the", "backend", ".", "The", "key", "is", "a", "method", "response", "header", "parameter", "name", "and", "the", "mapped", "value", "is", "an", "integration", "response", "header", "value", "a", "static", "value", "enclosed", "within", "a", "pair", "of", "single", "quotes", "or", "a", "JSON", "expression", "from", "the", "integration", "response", "body", ".", "The", "mapping", "key", "must", "match", "the", "pattern", "of", "method", ".", "response", ".", "header", ".", "{", "name", "}", "where", "name", "is", "a", "valid", "and", "unique", "header", "name", ".", "The", "mapped", "non", "-", "static", "value", "must", "match", "the", "pattern", "of", "integration", ".", "response", ".", "header", ".", "{", "name", "}", "or", "integration", ".", "response", ".", "body", ".", "{", "JSON", "-", "expression", "}", "where", "{", "name", "}", "is", "a", "valid", "and", "unique", "response", "header", "name", "and", "{", "JSON", "-", "expression", "}", "is", "a", "valid", "JSON", "expression", "without", "the", "$", "prefix", ".", "<", "/", "p", ">" ]

[ "public", "ConnectivityInformationInner", "beginCheckConnectivity", "(", "String", "resourceGroupName", ",", "String", "networkWatcherName", ",", "ConnectivityParameters", "parameters", ")", "{", "return", "beginCheckConnectivityWithServiceResponseAsync", "(", "resourceGroupName", ",", "networkWatcherName", ",", "parameters", ")", ".", "toBlocking", "(", ")", ".", "single", "(", ")", ".", "body", "(", ")", ";", "}" ]

[ "Verifies", "the", "possibility", "of", "establishing", "a", "direct", "TCP", "connection", "from", "a", "virtual", "machine", "to", "a", "given", "endpoint", "including", "another", "VM", "or", "an", "arbitrary", "remote", "server", "." ]

[ "private", "long", "calExpirationTime", "(", "long", "operatorTime", ",", "long", "relativeSize", ")", "{", "if", "(", "operatorTime", "<", "Long", ".", "MAX_VALUE", ")", "{", "return", "operatorTime", "-", "relativeSize", "-", "allowedLateness", "-", "1", ";", "}", "else", "{", "// When operatorTime = Long.MaxValue, it means the stream has reached the end.", "return", "Long", ".", "MAX_VALUE", ";", "}", "}" ]

[ "Calculate", "the", "expiration", "time", "with", "the", "given", "operator", "time", "and", "relative", "window", "size", "." ]

[ "@", "Override", "public", "XAResource", "getRRSXAResource", "(", "String", "activationSpecId", ",", "Xid", "xid", ")", "throws", "XAResourceNotAvailableException", "{", "RRSXAResourceFactory", "factory", "=", "rrsXAResFactorySvcRef", ".", "getService", "(", ")", ";", "if", "(", "factory", "==", "null", ")", "{", "return", "null", ";", "}", "else", "{", "return", "factory", ".", "getTwoPhaseXAResource", "(", "xid", ")", ";", "}", "}" ]

[ "Method", "to", "get", "the", "XAResource", "corresponding", "to", "an", "ActivationSpec", "from", "the", "RRSXAResourceFactory" ]

[ "public", "Result", "cmd", "(", "String", "cliCommand", ")", "{", "try", "{", "// The intent here is to return a Response when this is doable.", "if", "(", "ctx", ".", "isWorkflowMode", "(", ")", "||", "ctx", ".", "isBatchMode", "(", ")", ")", "{", "ctx", ".", "handle", "(", "cliCommand", ")", ";", "return", "new", "Result", "(", "cliCommand", ",", "ctx", ".", "getExitCode", "(", ")", ")", ";", "}", "handler", ".", "parse", "(", "ctx", ".", "getCurrentNodePath", "(", ")", ",", "cliCommand", ",", "ctx", ")", ";", "if", "(", "handler", ".", "getFormat", "(", ")", "==", "OperationFormat", ".", "INSTANCE", ")", "{", "ModelNode", "request", "=", "ctx", ".", "buildRequest", "(", "cliCommand", ")", ";", "ModelNode", "response", "=", "ctx", ".", "execute", "(", "request", ",", "cliCommand", ")", ";", "return", "new", "Result", "(", "cliCommand", ",", "request", ",", "response", ")", ";", "}", "else", "{", "ctx", ".", "handle", "(", "cliCommand", ")", ";", "return", "new", "Result", "(", "cliCommand", ",", "ctx", ".", "getExitCode", "(", ")", ")", ";", "}", "}", "catch", "(", "CommandLineException", "cfe", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Error handling command: \"", "+", "cliCommand", ",", "cfe", ")", ";", "}", "catch", "(", "IOException", "ioe", ")", "{", "throw", "new", "IllegalStateException", "(", "\"Unable to send command \"", "+", "cliCommand", "+", "\" to server.\"", ",", "ioe", ")", ";", "}", "}" ]

[ "Execute", "a", "CLI", "command", ".", "This", "can", "be", "any", "command", "that", "you", "might", "execute", "on", "the", "CLI", "command", "line", "including", "both", "server", "-", "side", "operations", "and", "local", "commands", "such", "as", "cd", "or", "cn", "." ]

[ "public", "CmsLinkTable", "getLinkTable", "(", "String", "name", ",", "Locale", "locale", ")", "{", "CmsXmlHtmlValue", "value", "=", "(", "CmsXmlHtmlValue", ")", "getValue", "(", "name", ",", "locale", ")", ";", "if", "(", "value", "!=", "null", ")", "{", "return", "value", ".", "getLinkTable", "(", ")", ";", "}", "return", "new", "CmsLinkTable", "(", ")", ";", "}" ]

[ "Returns", "the", "link", "table", "of", "an", "element", ".", "<p", ">" ]

[ "private", "Constant", "parseConstant", "(", "Node", "el", ",", "boolean", "ignoreCase", ")", "{", "return", "new", "Constant", "(", "nodeAttribute", "(", "el", ",", "TAG_CONSTANT_ATTR_VALUE", ")", ",", "nodeAttribute", "(", "el", ",", "TAG_CONSTANT_ATTR_IGNORE_CASE", ",", "ignoreCase", ")", ",", "nodeAttribute", "(", "el", ",", "TAG_ATTR_GHOST", ",", "PatternElement", ".", "DEFAULT_GHOST_VALUE", ")", ")", ";", "}" ]

[ "Parse", "constant", "pattern", "element" ]

[ "public", "void", "addNotEqualToColumn", "(", "String", "attribute", ",", "String", "colName", ")", "{", "// PAW\r", "// FieldCriteria c = FieldCriteria.buildNotEqualToCriteria(attribute, colName, getAlias());\r", "FieldCriteria", "c", "=", "FieldCriteria", ".", "buildNotEqualToCriteria", "(", "attribute", ",", "colName", ",", "getUserAlias", "(", "attribute", ")", ")", ";", "c", ".", "setTranslateField", "(", "false", ")", ";", "addSelectionCriteria", "(", "c", ")", ";", "}" ]

[ "Adds", "and", "equals", "(", "<", ">", ")", "criteria", "for", "column", "comparison", ".", "The", "column", "Name", "will", "NOT", "be", "translated", ".", "<br", ">", "name", "<", ">", "T_BOSS", ".", "LASTNMAE" ]

[ "public", "Connection", "createConnection", "(", "String", "url", ",", "String", "username", ",", "String", "password", ")", "throws", "SQLException", "{", "if", "(", "connection", "!=", "null", "&&", "!", "connection", ".", "isClosed", "(", ")", ")", "return", "connection", ";", "connection", "=", "DriverManager", ".", "getConnection", "(", "url", ",", "username", ",", "password", ")", ";", "return", "connection", ";", "}" ]

[ "Constructs", "a", "new", "database", "connection", "object", "and", "retrieves", "it", "." ]

[ "public", "void", "writeBits", "(", "final", "int", "aValue", ",", "@", "Nonnegative", "final", "int", "nNumBits", ")", "throws", "IOException", "{", "ValueEnforcer", ".", "isBetweenInclusive", "(", "nNumBits", ",", "\"NumberOfBits\"", ",", "1", ",", "CGlobal", ".", "BITS_PER_INT", ")", ";", "for", "(", "int", "i", "=", "nNumBits", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "writeBit", "(", "(", "aValue", ">>", "i", ")", "&", "1", ")", ";", "}", "/**\n * Write the current cache to the stream and reset the buffer.\n *\n * @throws IOException\n * In case writing to the output stream failed\n */", "public", "void", "flush", "(", ")", "throws", "IOException", "{", "if", "(", "m_nBufferedBitCount", ">", "0", ")", "{", "if", "(", "m_nBufferedBitCount", "!=", "CGlobal", ".", "BITS_PER_BYTE", ")", "if", "(", "LOGGER", ".", "isDebugEnabled", "(", ")", ")", "LOGGER", ".", "debug", "(", "\"Flushing BitOutputStream with only \"", "+", "m_nBufferedBitCount", "+", "\" bits\"", ")", ";", "m_aOS", ".", "write", "(", "(", "byte", ")", "m_nBuffer", ")", ";", "m_nBufferedBitCount", "=", "0", ";", "m_nBuffer", "=", "0", ";", "}", "}", "/**\n * Flush the data and close the underlying output stream.\n */", "public", "void", "close", "", "(", ")", "{", "StreamHelper", ".", "flush", "(", "this", ")", ";", "StreamHelper", ".", "close", "(", "m_aOS", ")", ";", "m_aOS", "=", "null", ";", "}", "@", "Override", "public", "String", "toString", "", "(", ")", "{", "return", "new", "ToStringGenerator", "(", "this", ")", ".", "append", "(", "\"OS\"", ",", "m_aOS", ")", ".", "append", "(", "\"highOrderBitFirst\"", ",", "m_bHighOrderBitFirst", ")", ".", "append", "(", "\"buffer\"", ",", "m_nBuffer", ")", ".", "append", "(", "\"bitCount\"", ",", "m_nBufferedBitCount", ")", ".", "getToString", "(", ")", ";", "}", "}" ]

[ "Write", "the", "specified", "number", "of", "bits", "from", "the", "int", "value", "to", "the", "stream", ".", "Corresponding", "to", "the", "InputStream", "the", "bits", "are", "written", "starting", "at", "the", "highest", "bit", "(", "&gt", ";", "&gt", ";", "aNumberOfBits", ")", "going", "down", "to", "the", "lowest", "bit", "(", "&gt", ";", "&gt", ";", "0", ")", "." ]

[ "public", "static", "boolean", "resetSuffixLength", "(", "JcsegTaskConfig", "config", ",", "ADictionary", "dic", ",", "int", "mixLength", ")", "{", "if", "(", "mixLength", "<=", "config", ".", "MAX_LENGTH", "&&", "mixLength", ">", "dic", ".", "mixSuffixLength", ")", "{", "dic", ".", "mixSuffixLength", "=", "mixLength", ";", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "check", "and", "reset", "the", "value", "of", "the", "{", "@link", "ADictionary#mixSuffixLength", "}" ]

[ "private", "void", "completeMultipart", "(", "String", "bucketName", ",", "String", "objectName", ",", "String", "uploadId", ",", "Part", "[", "]", "parts", ")", "throws", "InvalidBucketNameException", ",", "NoSuchAlgorithmException", ",", "InsufficientDataException", ",", "IOException", ",", "InvalidKeyException", ",", "NoResponseException", ",", "XmlPullParserException", ",", "ErrorResponseException", ",", "InternalException", "{", "Map", "<", "String", ",", "String", ">", "queryParamMap", "=", "new", "HashMap", "<>", "(", ")", ";", "queryParamMap", ".", "put", "(", "UPLOAD_ID", ",", "uploadId", ")", ";", "CompleteMultipartUpload", "completeManifest", "=", "new", "CompleteMultipartUpload", "(", "parts", ")", ";", "HttpResponse", "response", "=", "executePost", "(", "bucketName", ",", "objectName", ",", "null", ",", "queryParamMap", ",", "completeManifest", ")", ";", "// Fixing issue https://github.com/minio/minio-java/issues/391", "String", "bodyContent", "=", "\"\"", ";", "Scanner", "scanner", "=", "new", "Scanner", "(", "response", ".", "body", "(", ")", ".", "charStream", "(", ")", ")", ";", "try", "{", "// read entire body stream to string.", "scanner", ".", "useDelimiter", "(", "\"\\\\A\"", ")", ";", "if", "(", "scanner", ".", "hasNext", "(", ")", ")", "{", "bodyContent", "=", "scanner", ".", "next", "(", ")", ";", "}", "}", "finally", "{", "response", ".", "body", "(", ")", ".", "close", "(", ")", ";", "scanner", ".", "close", "(", ")", ";", "}", "bodyContent", "=", "bodyContent", ".", "trim", "(", ")", ";", "if", "(", "!", "bodyContent", ".", "isEmpty", "(", ")", ")", "{", "ErrorResponse", "errorResponse", "=", "new", "ErrorResponse", "(", "new", "StringReader", "(", "bodyContent", ")", ")", ";", "if", "(", "errorResponse", ".", "code", "(", ")", "!=", "null", ")", "{", "throw", "new", "ErrorResponseException", "(", "errorResponse", ",", "response", ".", "response", "(", ")", ")", ";", "}", "}", "}" ]

[ "Executes", "complete", "multipart", "upload", "of", "given", "bucket", "name", "object", "name", "upload", "ID", "and", "parts", "." ]

[ "public", "Observable", "<", "Page", "<", "ElasticPoolInner", ">", ">", "listByServerAsync", "(", "final", "String", "resourceGroupName", ",", "final", "String", "serverName", ",", "final", "Integer", "skip", ")", "{", "return", "listByServerWithServiceResponseAsync", "(", "resourceGroupName", ",", "serverName", ",", "skip", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "Page", "<", "ElasticPoolInner", ">", ">", ",", "Page", "<", "ElasticPoolInner", ">", ">", "(", ")", "{", "@", "Override", "public", "Page", "<", "ElasticPoolInner", ">", "call", "(", "ServiceResponse", "<", "Page", "<", "ElasticPoolInner", ">", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Gets", "all", "elastic", "pools", "in", "a", "server", "." ]

[ "public", "Set", "<", "ODocument", ">", "getEdgesBetweenVertexes", "(", "final", "ODocument", "iVertex1", ",", "final", "ODocument", "iVertex2", ",", "final", "String", "[", "]", "iLabels", ")", "{", "return", "getEdgesBetweenVertexes", "(", "iVertex1", ",", "iVertex2", ",", "iLabels", ",", "null", ")", ";", "}" ]

[ "Returns", "all", "the", "edges", "between", "the", "vertexes", "iVertex1", "and", "iVertex2", "with", "label", "between", "the", "array", "of", "labels", "passed", "as", "iLabels", "." ]

[ "@", "VisibleForTesting", "boolean", "containsListRaw", "(", "String", "bucket", ",", "String", "objectName", ")", "{", "return", "prefixMap", ".", "containsKey", "(", "new", "PrefixKey", "(", "bucket", ",", "objectName", ")", ")", ";", "}" ]

[ "Checks", "if", "the", "prefix", "map", "contains", "an", "exact", "entry", "for", "the", "given", "bucket", "/", "objectName", "." ]

[ "public", "void", "setCenterColor", "(", "Color", "color", ")", "{", "if", "(", "centerColor", "==", "null", ")", "{", "centerColor", "=", "new", "RGBColor", "(", "0.0", ",", "0.0", ",", "0.0", ")", ";", "}", "setGradation", "(", "true", ")", ";", "this", ".", "centerColor", "=", "color", ";", "}" ]

[ "Sets", "the", "color", "of", "this", "Ellipse", "s", "center", "." ]

[ "public", "void", "addPredicate", "(", "final", "INodeReadTrx", "mTransaction", ")", "{", "assert", "getPipeStack", "(", ")", ".", "size", "(", ")", ">=", "2", ";", "final", "AbsAxis", "mPredicate", "=", "getPipeStack", "(", ")", ".", "pop", "(", ")", ".", "getExpr", "(", ")", ";", "if", "(", "mPredicate", "instanceof", "LiteralExpr", ")", "{", "mPredicate", ".", "hasNext", "(", ")", ";", "// if is numeric literal -> abbrev for position()", "final", "int", "type", "=", "mTransaction", ".", "getNode", "(", ")", ".", "getTypeKey", "(", ")", ";", "if", "(", "type", "==", "NamePageHash", ".", "generateHashForString", "(", "\"xs:integer\"", ")", "||", "type", "==", "NamePageHash", ".", "generateHashForString", "(", "\"xs:double\"", ")", "||", "type", "==", "NamePageHash", ".", "generateHashForString", "(", "\"xs:float\"", ")", "||", "type", "==", "NamePageHash", ".", "generateHashForString", "(", "\"xs:decimal\"", ")", ")", "{", "throw", "new", "IllegalStateException", "(", "\"function fn:position() is not implemented yet.\"", ")", ";", "// getExpression().add(", "// new PosFilter(transaction, (int)", "// Double.parseDouble(transaction", "// .getValue())));", "// return; // TODO: YES! it is dirty!", "// AtomicValue pos =", "// new AtomicValue(mTransaction.getNode().getRawValue(),", "// mTransaction", "// .keyForName(\"xs:integer\"));", "// long position = mTransaction.getItemList().addItem(pos);", "// mPredicate.reset(mTransaction.getNode().getNodeKey());", "// IAxis function =", "// new FNPosition(mTransaction, new ArrayList<IAxis>(),", "// FuncDef.POS.getMin(), FuncDef.POS", "// .getMax(),", "// mTransaction.keyForName(FuncDef.POS.getReturnType()));", "// IAxis expectedPos = new LiteralExpr(mTransaction, position);", "//", "// mPredicate = new ValueComp(mTransaction, function,", "// expectedPos, CompKind.EQ);", "}", "}", "getExpression", "(", ")", ".", "add", "(", "new", "PredicateFilterAxis", "(", "mTransaction", ",", "mPredicate", ")", ")", ";", "}" ]

[ "Adds", "a", "predicate", "to", "the", "pipeline", "." ]

[ "public", "void", "writePropertyObject", "(", "CmsRequestContext", "context", ",", "CmsResource", "resource", ",", "CmsProperty", "property", ")", "throws", "CmsException", ",", "CmsSecurityException", "{", "CmsDbContext", "dbc", "=", "m_dbContextFactory", ".", "getDbContext", "(", "context", ")", ";", "try", "{", "checkOfflineProject", "(", "dbc", ")", ";", "checkPermissions", "(", "dbc", ",", "resource", ",", "CmsPermissionSet", ".", "ACCESS_WRITE", ",", "true", ",", "CmsResourceFilter", ".", "IGNORE_EXPIRATION", ")", ";", "m_driverManager", ".", "writePropertyObject", "(", "dbc", ",", "resource", ",", "property", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "dbc", ".", "report", "(", "null", ",", "Messages", ".", "get", "(", ")", ".", "container", "(", "Messages", ".", "ERR_WRITE_PROP_2", ",", "property", ".", "getName", "(", ")", ",", "context", ".", "getSitePath", "(", "resource", ")", ")", ",", "e", ")", ";", "}", "finally", "{", "dbc", ".", "clear", "(", ")", ";", "}", "}" ]

[ "Writes", "a", "property", "for", "a", "specified", "resource", ".", "<p", ">" ]

[ "private", "boolean", "valueEquals", "(", "V", "leftValue", ",", "V", "rightValue", ")", "{", "if", "(", "leftValue", "==", "rightValue", ")", "{", "return", "true", ";", "}", "if", "(", "leftValue", "==", "null", "||", "rightValue", "==", "null", ")", "{", "return", "false", ";", "}", "return", "leftValue", ".", "equals", "(", "rightValue", ")", ";", "}" ]

[ "Value", "equals", "." ]

[ "public", "boolean", "isUninstallable", "(", "UninstallAsset", "uninstallAsset", ",", "Set", "<", "IFixInfo", ">", "installedFixes", ",", "List", "<", "UninstallAsset", ">", "uninstallAssets", ")", "{", "if", "(", "Boolean", ".", "valueOf", "(", "System", ".", "getenv", "(", "S_DISABLE", ")", ")", ".", "booleanValue", "(", ")", ")", "{", "return", "true", ";", "}", "IFixInfo", "fixToBeUninstalled", "=", "uninstallAsset", ".", "getIFixInfo", "(", ")", ";", "for", "(", "IFixInfo", "fix", ":", "installedFixes", ")", "{", "if", "(", "!", "(", "fixToBeUninstalled", ".", "getId", "(", ")", ".", "equals", "(", "fix", ".", "getId", "(", ")", ")", ")", ")", "{", "if", "(", "(", "!", "confirmNoFileConflicts", "(", "fixToBeUninstalled", ".", "getUpdates", "(", ")", ".", "getFiles", "(", ")", ",", "fix", ".", "getUpdates", "(", ")", ".", "getFiles", "(", ")", ")", ")", "&&", "(", "!", "isSupersededBy", "(", "fix", ".", "getResolves", "(", ")", ".", "getProblems", "(", ")", ",", "fixToBeUninstalled", ".", "getResolves", "(", ")", ".", "getProblems", "(", ")", ")", ")", ")", "if", "(", "!", "isToBeUninstalled", "(", "fix", ".", "getId", "(", ")", ",", "uninstallAssets", ")", ")", "return", "false", ";", "}", "}", "return", "true", ";", "}" ]

[ "Verfiy", "whether", "the", "fix", "is", "uninstallable", "and", "there", "is", "no", "other", "installed", "fix", "still", "require", "this", "feature", "." ]

[ "public", "Class", "<", "?", ">", "findClass", "(", "String", "className", ")", "{", "Class", "<", "?", ">", "result", "=", "null", ";", "// look in hash map\r", "result", "=", "(", "Class", "<", "?", ">", ")", "classes", ".", "get", "(", "className", ")", ";", "if", "(", "result", "!=", "null", ")", "{", "return", "result", ";", "}", "try", "{", "return", "findSystemClass", "(", "className", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "Debugger", ".", "printWarn", "(", "e", ")", ";", "}", "try", "{", "URL", "resourceURL", "=", "ClassLoader", ".", "getSystemResource", "(", "className", ".", "replace", "(", "'", "'", ",", "File", ".", "separatorChar", ")", "+", "\".class\"", ")", ";", "if", "(", "resourceURL", "==", "null", ")", "return", "null", ";", "String", "classPath", "=", "resourceURL", ".", "getFile", "(", ")", ";", "classPath", "=", "classPath", ".", "substring", "(", "1", ")", ";", "return", "loadClass", "(", "className", ",", "new", "File", "(", "classPath", ")", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "Debugger", ".", "printError", "(", "e", ")", ";", "return", "null", ";", "}", "}" ]

[ "Find", "the", "class", "by", "it", "name" ]

[ "protected", "CmsContainerElementBean", "elementFromJson", "(", "JSONObject", "data", ")", "throws", "JSONException", "{", "CmsUUID", "element", "=", "new", "CmsUUID", "(", "data", ".", "getString", "(", "FavListProp", ".", "ELEMENT", ".", "name", "(", ")", ".", "toLowerCase", "(", ")", ")", ")", ";", "CmsUUID", "formatter", "=", "null", ";", "if", "(", "data", ".", "has", "(", "FavListProp", ".", "FORMATTER", ".", "name", "(", ")", ".", "toLowerCase", "(", ")", ")", ")", "{", "formatter", "=", "new", "CmsUUID", "(", "data", ".", "getString", "(", "FavListProp", ".", "FORMATTER", ".", "name", "(", ")", ".", "toLowerCase", "(", ")", ")", ")", ";", "}", "Map", "<", "String", ",", "String", ">", "properties", "=", "new", "HashMap", "<", "String", ",", "String", ">", "(", ")", ";", "JSONObject", "props", "=", "data", ".", "getJSONObject", "(", "FavListProp", ".", "PROPERTIES", ".", "name", "(", ")", ".", "toLowerCase", "(", ")", ")", ";", "Iterator", "<", "String", ">", "keys", "=", "props", ".", "keys", "(", ")", ";", "while", "(", "keys", ".", "hasNext", "(", ")", ")", "{", "String", "key", "=", "keys", ".", "next", "(", ")", ";", "properties", ".", "put", "(", "key", ",", "props", ".", "getString", "(", "key", ")", ")", ";", "}", "return", "new", "CmsContainerElementBean", "(", "element", ",", "formatter", ",", "properties", ",", "false", ")", ";", "}" ]

[ "Creates", "an", "element", "from", "its", "serialized", "data", ".", "<p", ">" ]

[ "public", "static", "synchronized", "<", "T", ">", "T", "createStrictMockAndExpectNew", "(", "Class", "<", "T", ">", "type", ",", "Object", "...", "arguments", ")", "throws", "Exception", "{", "T", "mock", "=", "createStrictMock", "(", "type", ")", ";", "expectStrictNew", "(", "type", ",", "arguments", ")", ".", "andReturn", "(", "mock", ")", ";", "return", "mock", ";", "}" ]

[ "Convenience", "method", "for", "createStrictMock", "followed", "by", "expectNew", "." ]

[ "public", "static", "Channel", "interceptForward", "(", "Channel", "channel", ",", "List", "<", "?", "extends", "ClientInterceptor", ">", "interceptors", ")", "{", "List", "<", "?", "extends", "ClientInterceptor", ">", "copy", "=", "new", "ArrayList", "<>", "(", "interceptors", ")", ";", "Collections", ".", "reverse", "(", "copy", ")", ";", "return", "intercept", "(", "channel", ",", "copy", ")", ";", "}" ]

[ "Create", "a", "new", "{", "@link", "Channel", "}", "that", "will", "call", "{", "@code", "interceptors", "}", "before", "starting", "a", "call", "on", "the", "given", "channel", ".", "The", "first", "interceptor", "will", "have", "its", "{", "@link", "ClientInterceptor#interceptCall", "}", "called", "first", "." ]

[ "public", "PendingIntent", "buildPendingIntent", "(", "int", "requestCode", ",", "int", "flags", ",", "IntentFactoryStrategy", "parameters", ")", "{", "return", "PendingIntent", ".", "getActivity", "(", "context", ",", "requestCode", ",", "buildIntent", "(", "parameters", ")", ",", "flags", ")", ";", "}" ]

[ "Build", "a", "PendingIntent", "specified", "by", "the", "given", "input", "Strategy", "." ]

[ "public", "ExecutionVertex", "getInputVertex", "(", "final", "int", "stage", ",", "final", "int", "index", ")", "{", "try", "{", "final", "ExecutionStage", "s", "=", "this", ".", "stages", ".", "get", "(", "stage", ")", ";", "if", "(", "s", "==", "null", ")", "{", "return", "null", ";", "}", "return", "s", ".", "getInputExecutionVertex", "(", "index", ")", ";", "}", "catch", "(", "ArrayIndexOutOfBoundsException", "e", ")", "{", "return", "null", ";", "}", "}" ]

[ "Returns", "the", "input", "vertex", "with", "the", "specified", "index", "for", "the", "given", "stage" ]

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

[ "The", "GetBgpPeerStatus", "operation", "retrieves", "the", "status", "of", "all", "BGP", "peers", "." ]

[ "public", "BitReader", "openReader", "(", ")", "throws", "BitStreamException", "{", "try", "{", "switch", "(", "mode", ")", "{", "case", "MEMORY", ":", "return", "new", "ByteArrayBitReader", "(", "getBytes", "(", ")", ")", ";", "case", "STREAM", ":", "return", "new", "InputStreamBitReader", "(", "new", "BufferedInputStream", "(", "new", "FileInputStream", "(", "file", ")", ",", "bufferSize", ")", ")", ";", "case", "CHANNEL", ":", "return", "new", "FileChannelBitReader", "(", "new", "RandomAccessFile", "(", "file", ",", "\"r\"", ")", ".", "getChannel", "(", ")", ",", "ByteBuffer", ".", "allocateDirect", "(", "bufferSize", ")", ")", ";", "default", ":", "throw", "new", "IllegalStateException", "(", "\"Unexpected mode: \"", "+", "mode", ")", ";", "}", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "new", "BitStreamException", "(", "e", ")", ";", "}", "}" ]

[ "Opens", "a", "reader", "over", "the", "bits", "of", "the", "file", ".", "The", "characteristics", "of", "the", "returned", "reader", "are", "determined", "by", "the", "{", "@link", "Mode", "}", "in", "which", "the", "factory", "was", "created", "." ]

[ "public", "boolean", "evaluateSprintLength", "(", "String", "startDate", ",", "String", "endDate", ",", "int", "maxKanbanIterationLength", ")", "{", "boolean", "sprintIndicator", "=", "false", ";", "Calendar", "startCalendar", "=", "Calendar", ".", "getInstance", "(", ")", ";", "Calendar", "endCalendar", "=", "Calendar", ".", "getInstance", "(", ")", ";", "if", "(", "!", "StringUtils", ".", "isAnyEmpty", "(", "startDate", ")", "&&", "!", "StringUtils", ".", "isAnyEmpty", "(", "endDate", ")", ")", "{", "Date", "strDt", "=", "convertIntoDate", "(", "startDate", ".", "substring", "(", "0", ",", "4", ")", "+", "\"-\"", "+", "startDate", ".", "substring", "(", "5", ",", "7", ")", "+", "\"-\"", "+", "startDate", ".", "substring", "(", "8", ",", "10", ")", ",", "\"yyyy-MM-dd\"", ")", ";", "Date", "endDt", "=", "convertIntoDate", "(", "endDate", ".", "substring", "(", "0", ",", "4", ")", "+", "\"-\"", "+", "endDate", ".", "substring", "(", "5", ",", "7", ")", "+", "\"-\"", "+", "endDate", ".", "substring", "(", "8", ",", "10", ")", ",", "\"yyyy-MM-dd\"", ")", ";", "if", "(", "strDt", "!=", "null", "&&", "endDate", "!=", "null", ")", "{", "startCalendar", ".", "setTime", "(", "strDt", ")", ";", "endCalendar", ".", "setTime", "(", "endDt", ")", ";", "long", "diffMill", "=", "endCalendar", ".", "getTimeInMillis", "(", ")", "-", "startCalendar", ".", "getTimeInMillis", "(", ")", ";", "long", "diffDays", "=", "TimeUnit", ".", "DAYS", ".", "convert", "(", "diffMill", ",", "TimeUnit", ".", "MILLISECONDS", ")", ";", "if", "(", "diffDays", "<=", "maxKanbanIterationLength", ")", "{", "// Scrum-enough", "sprintIndicator", "=", "true", ";", "}", "}", "}", "else", "{", "// Default to kanban", "sprintIndicator", "=", "false", ";", "}", "return", "sprintIndicator", ";", "}" ]

[ "Evaluates", "whether", "a", "sprint", "length", "appears", "to", "be", "kanban", "or", "scrum" ]

[ "public", "static", "boolean", "match", "(", "SkippableIterator", "o1", ",", "SkippableIterator", "o2", ")", "{", "while", "(", "o1", ".", "getCurrentWordOffset", "(", ")", "!=", "o2", ".", "getCurrentWordOffset", "(", ")", ")", "{", "if", "(", "o1", ".", "getCurrentWordOffset", "(", ")", "<", "o2", ".", "getCurrentWordOffset", "(", ")", ")", "{", "o1", ".", "advanceUntil", "(", "o2", ".", "getCurrentWordOffset", "(", ")", ")", ";", "if", "(", "!", "o1", ".", "hasValue", "(", ")", ")", "return", "false", ";", "}", "if", "(", "o1", ".", "getCurrentWordOffset", "(", ")", ">", "o2", ".", "getCurrentWordOffset", "(", ")", ")", "{", "o2", ".", "advanceUntil", "(", "o1", ".", "getCurrentWordOffset", "(", ")", ")", ";", "if", "(", "!", "o2", ".", "hasValue", "(", ")", ")", "return", "false", ";", "}", "}", "return", "true", ";", "}" ]

[ "Synchronize", "two", "iterators" ]

[ "static", "AccountingDate", "ofYearDay", "(", "AccountingChronology", "chronology", ",", "int", "prolepticYear", ",", "int", "dayOfYear", ")", "{", "Objects", ".", "requireNonNull", "(", "chronology", ",", "\"A previously setup chronology is required.\"", ")", ";", "YEAR", ".", "checkValidValue", "(", "prolepticYear", ")", ";", "DAY_OF_YEAR_RANGE", ".", "checkValidValue", "(", "dayOfYear", ",", "DAY_OF_YEAR", ")", ";", "boolean", "leap", "=", "chronology", ".", "isLeapYear", "(", "prolepticYear", ")", ";", "if", "(", "dayOfYear", ">", "WEEKS_IN_YEAR", "*", "DAYS_IN_WEEK", "&&", "!", "leap", ")", "{", "throw", "new", "DateTimeException", "(", "\"Invalid date 'DayOfYear \"", "+", "dayOfYear", "+", "\"' as '\"", "+", "prolepticYear", "+", "\"' is not a leap year\"", ")", ";", "}", "int", "month", "=", "(", "leap", "?", "chronology", ".", "getDivision", "(", ")", ".", "getMonthFromElapsedWeeks", "(", "(", "dayOfYear", "-", "1", ")", "/", "DAYS_IN_WEEK", ",", "chronology", ".", "getLeapWeekInMonth", "(", ")", ")", ":", "chronology", ".", "getDivision", "(", ")", ".", "getMonthFromElapsedWeeks", "(", "(", "dayOfYear", "-", "1", ")", "/", "DAYS_IN_WEEK", ")", ")", ";", "int", "dayOfMonth", "=", "dayOfYear", "-", "(", "leap", "?", "chronology", ".", "getDivision", "(", ")", ".", "getWeeksAtStartOfMonth", "(", "month", ",", "chronology", ".", "getLeapWeekInMonth", "(", ")", ")", ":", "chronology", ".", "getDivision", "(", ")", ".", "getWeeksAtStartOfMonth", "(", "month", ")", ")", "*", "DAYS_IN_WEEK", ";", "return", "new", "AccountingDate", "(", "chronology", ",", "prolepticYear", ",", "month", ",", "dayOfMonth", ")", ";", "}" ]

[ "Obtains", "an", "{", "@code", "AccountingDate", "}", "representing", "a", "date", "in", "the", "given", "Accounting", "calendar", "system", "from", "the", "proleptic", "-", "year", "and", "day", "-", "of", "-", "year", "fields", ".", "<p", ">", "This", "returns", "an", "{", "@code", "AccountingDate", "}", "with", "the", "specified", "fields", ".", "The", "day", "must", "be", "valid", "for", "the", "year", "otherwise", "an", "exception", "will", "be", "thrown", "." ]

[ "public", "static", "Matcher", "getMatcher", "(", "String", "pattern", ",", "CharSequence", "input", ")", "{", "if", "(", "pattern", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"String 'pattern' must not be null\"", ")", ";", "}", "input", "=", "new", "InterruptibleCharSequence", "(", "input", ")", ";", "final", "Map", "<", "String", ",", "Matcher", ">", "matchers", "=", "TL_MATCHER_MAP", ".", "get", "(", ")", ";", "Matcher", "m", "=", "(", "Matcher", ")", "matchers", ".", "get", "(", "pattern", ")", ";", "if", "(", "m", "==", "null", ")", "{", "m", "=", "PATTERNS", ".", "getUnchecked", "(", "pattern", ")", ".", "matcher", "(", "input", ")", ";", "}", "else", "{", "matchers", ".", "put", "(", "pattern", ",", "null", ")", ";", "m", ".", "reset", "(", "input", ")", ";", "}", "return", "m", ";", "}" ]

[ "Get", "a", "matcher", "object", "for", "a", "precompiled", "regex", "pattern", "." ]

[ "private", "static", "File", "writeToMapped", "(", "BytesMessage", "msg", ",", "File", "file", ")", "throws", "IOException", ",", "JMSException", "{", "// writeToMapped(msg, file.toPath());", "ByteBuffer", "buf", ";", "FileChannel", "fc", "=", "null", ";", "RandomAccessFile", "raf", "=", "null", ";", "try", "{", "raf", "=", "new", "RandomAccessFile", "(", "file", ",", "\"rw\"", ")", ";", "fc", "=", "raf", ".", "getChannel", "(", ")", ";", "buf", "=", "fc", ".", "map", "(", "FileChannel", ".", "MapMode", ".", "READ_WRITE", ",", "0", ",", "msg", ".", "getBodyLength", "(", ")", ")", ";", "logger", ".", "debug", "(", "\"Writting message to byte buffer.\"", ")", ";", "writeTo", "(", "msg", ",", "buf", ")", ";", "logger", ".", "debug", "(", "\"Success writing message to file {} using file map. Closing\"", ",", "file", ")", ";", "fc", ".", "close", "(", ")", ";", "raf", ".", "close", "(", ")", ";", "return", "file", ";", "}", "finally", "{", "fc", "=", "Closer", ".", "close", "(", "fc", ")", ";", "raf", "=", "Closer", ".", "close", "(", "raf", ")", ";", "}", "}" ]

[ "/", "*", "blasted", ".", "java", "7", "private", "static", "Path", "writeToMapped", "(", "BytesMessage", "msg", "Path", "path", ")", "throws", "IOException", "JMSException", "{", "ByteBuffer", "buf", ";", "FileChannel", "fc", ";" ]

[ "private", "long", "readTimeStamp", "(", "byte", "[", "]", "buffer", ",", "int", "offset", ")", "{", "long", "seconds", "=", "read32", "(", "buffer", ",", "offset", ")", ";", "long", "fraction", "=", "read32", "(", "buffer", ",", "offset", "+", "4", ")", ";", "return", "(", "(", "seconds", "-", "OFFSET_1900_TO_1970", ")", "*", "1000", ")", "+", "(", "(", "fraction", "*", "1000L", ")", "/", "0x100000000", "L", ")", ";", "}" ]

[ "Reads", "the", "NTP", "time", "stamp", "at", "the", "given", "offset", "in", "the", "buffer", "and", "returns", "it", "as", "a", "system", "time", "(", "milliseconds", "since", "January", "1", "1970", ")", "." ]

[ "public", "String", "getCacheKey", "(", "String", "siteRoot", ",", "String", "uri", ")", "{", "return", "new", "StringBuffer", "(", "siteRoot", ")", ".", "append", "(", "uri", ")", ".", "toString", "(", ")", ";", "}" ]

[ "Returns", "the", "key", "for", "the", "online", "export", "and", "secure", "cache", ".", "<p", ">" ]

[ "public", "Matrix4f", "lookAtLH", "(", "float", "eyeX", ",", "float", "eyeY", ",", "float", "eyeZ", ",", "float", "centerX", ",", "float", "centerY", ",", "float", "centerZ", ",", "float", "upX", ",", "float", "upY", ",", "float", "upZ", ")", "{", "return", "lookAtLH", "(", "eyeX", ",", "eyeY", ",", "eyeZ", ",", "centerX", ",", "centerY", ",", "centerZ", ",", "upX", ",", "upY", ",", "upZ", ",", "thisOrNew", "(", ")", ")", ";", "}" ]

[ "Apply", "a", "lookat", "transformation", "to", "this", "matrix", "for", "a", "left", "-", "handed", "coordinate", "system", "that", "aligns", "<code", ">", "+", "z<", "/", "code", ">", "with", "<code", ">", "center", "-", "eye<", "/", "code", ">", ".", "<p", ">", "If", "<code", ">", "M<", "/", "code", ">", "is", "<code", ">", "this<", "/", "code", ">", "matrix", "and", "<code", ">", "L<", "/", "code", ">", "the", "lookat", "matrix", "then", "the", "new", "matrix", "will", "be", "<code", ">", "M", "*", "L<", "/", "code", ">", ".", "So", "when", "transforming", "a", "vector", "<code", ">", "v<", "/", "code", ">", "with", "the", "new", "matrix", "by", "using", "<code", ">", "M", "*", "L", "*", "v<", "/", "code", ">", "the", "lookat", "transformation", "will", "be", "applied", "first!", "<p", ">", "In", "order", "to", "set", "the", "matrix", "to", "a", "lookat", "transformation", "without", "post", "-", "multiplying", "it", "use", "{", "@link", "#setLookAtLH", "(", "float", "float", "float", "float", "float", "float", "float", "float", "float", ")", "setLookAtLH", "()", "}", "." ]

[ "@", "Conditioned", "@", "Quand", "(", "\"Je clique via js sur xpath '(.*)' de '(.*)' page[\\\\.|\\\\?]\"", ")", "@", "When", "(", "\"I click by js on xpath '(.*)' from '(.*)' page[\\\\.|\\\\?]\"", ")", "public", "void", "clickOnXpathByJs", "(", "String", "xpath", ",", "String", "page", ",", "List", "<", "GherkinStepCondition", ">", "conditions", ")", "throws", "TechnicalException", ",", "FailureException", "{", "logger", ".", "debug", "(", "\"clickOnByJs with xpath {} on {} page\"", ",", "xpath", ",", "page", ")", ";", "clickOnByJs", "(", "Page", ".", "getInstance", "(", "page", ")", ",", "xpath", ")", ";", "}" ]

[ "Click", "on", "html", "element", "using", "Javascript", "if", "all", "expected", "parameters", "equals", "actual", "parameters", "in", "conditions", "." ]

[ "public", "static", "IndexChangeAdapter", "forMixinTypes", "(", "ExecutionContext", "context", ",", "NodeTypePredicate", "matcher", ",", "String", "workspaceName", ",", "ProvidedIndex", "<", "?", ">", "index", ")", "{", "return", "new", "MixinTypesChangeAdapter", "(", "context", ",", "matcher", ",", "workspaceName", ",", "index", ")", ";", "}" ]

[ "Create", "an", "{", "@link", "IndexChangeAdapter", "}", "implementation", "that", "handles", "the", "jcr", ":", "mixinTypes", "property", "." ]

[ "public", "static", "double", "quickSelect", "(", "double", "[", "]", "data", ",", "int", "rank", ")", "{", "quickSelect", "(", "data", ",", "0", ",", "data", ".", "length", ",", "rank", ")", ";", "return", "data", "[", "rank", "]", ";", "}" ]

[ "QuickSelect", "is", "essentially", "quicksort", "except", "that", "we", "only", "sort", "that", "half", "of", "the", "array", "that", "we", "are", "interested", "in", "." ]

[ "@", "Override", "public", "void", "setBytes", "(", "int", "parameterIndex", ",", "byte", "[", "]", "x", ")", "throws", "SQLException", "{", "checkParameterBounds", "(", "parameterIndex", ")", ";", "this", ".", "parameters", "[", "parameterIndex", "-", "1", "]", "=", "x", ";", "}" ]

[ "Sets", "the", "designated", "parameter", "to", "the", "given", "Java", "array", "of", "bytes", "." ]

[ "public", "void", "sendEvent", "(", "String", "eventId", ",", "Set", "<", "Privilege", ">", "privileges", ")", "{", "// TODO do not use yml in json events...", "String", "ymlPrivileges", "=", "PrivilegeMapper", ".", "privilegesToYml", "(", "privileges", ")", ";", "SystemEvent", "event", "=", "buildSystemEvent", "(", "eventId", ",", "ymlPrivileges", ")", ";", "serializeEvent", "(", "event", ")", ".", "ifPresent", "(", "this", "::", "send", ")", ";", "}" ]

[ "Build", "MS_PRIVILEGES", "message", "for", "system", "queue", "event", "and", "send", "it", "." ]

[ "public", "void", "unregisterService", "(", "String", "serviceName", ",", "String", "providerAddress", ")", "{", "getServiceDirectoryClient", "(", ")", ".", "unregisterInstance", "(", "serviceName", ",", "providerAddress", ",", "disableOwnerError", ")", ";", "}" ]

[ "Unregister", "a", "ProvidedServiceInstance", "The", "ProvidedServiceInstance", "is", "uniquely", "identified", "by", "serviceName", "and", "providerAddress" ]

[ "protected", "String", "handleAuthenticationException", "(", "final", "AuthenticationException", "e", ",", "final", "RequestContext", "requestContext", ")", "{", "if", "(", "e", ".", "getHandlerErrors", "(", ")", ".", "containsKey", "(", "UnauthorizedServiceForPrincipalException", ".", "class", ".", "getSimpleName", "(", ")", ")", ")", "{", "val", "url", "=", "WebUtils", ".", "getUnauthorizedRedirectUrlFromFlowScope", "(", "requestContext", ")", ";", "if", "(", "url", "!=", "null", ")", "{", "LOGGER", ".", "warn", "(", "\"Unauthorized service access for principal; CAS will be redirecting to [{}]\"", ",", "url", ")", ";", "return", "CasWebflowConstants", ".", "STATE_ID_SERVICE_UNAUTHZ_CHECK", ";", "}", "}", "val", "values", "=", "e", ".", "getHandlerErrors", "(", ")", ".", "values", "(", ")", ".", "stream", "(", ")", ".", "map", "(", "Throwable", "::", "getClass", ")", ".", "collect", "(", "Collectors", ".", "toList", "(", ")", ")", ";", "val", "handlerErrorName", "=", "this", ".", "errors", ".", "stream", "(", ")", ".", "filter", "(", "values", "::", "contains", ")", ".", "map", "(", "Class", "::", "getSimpleName", ")", ".", "findFirst", "(", ")", ".", "orElseGet", "(", "(", ")", "->", "{", "LOGGER", ".", "debug", "(", "\"Unable to translate handler errors of the authentication exception [{}]. Returning [{}]\"", ",", "e", ",", "UNKNOWN", ")", ";", "return", "UNKNOWN", ";", "}", ")", ";", "val", "messageContext", "=", "requestContext", ".", "getMessageContext", "(", ")", ";", "val", "messageCode", "=", "this", ".", "messageBundlePrefix", "+", "handlerErrorName", ";", "messageContext", ".", "addMessage", "(", "new", "MessageBuilder", "(", ")", ".", "error", "(", ")", ".", "code", "(", "messageCode", ")", ".", "build", "(", ")", ")", ";", "return", "handlerErrorName", ";", "}" ]

[ "Maps", "an", "authentication", "exception", "onto", "a", "state", "name", "equal", "to", "the", "simple", "class", "name", "of", "the", "handler", "errors", ".", "with", "highest", "precedence", ".", "Also", "sets", "an", "ERROR", "severity", "message", "in", "the", "message", "context", "of", "the", "form", "{", "@code", "[", "messageBundlePrefix", "]", "[", "exceptionClassSimpleName", "]", "}", "for", "for", "the", "first", "handler", "error", "that", "is", "configured", ".", "If", "no", "match", "is", "found", "{", "@value", "#UNKNOWN", "}", "is", "returned", "." ]

[ "public", "static", "DataSource", "oracleDbDataSource", "(", "String", "url", ",", "String", "user", ",", "String", "password", ")", "{", "try", "{", "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "Class", "<", "?", "extends", "DataSource", ">", "dataSourceClass", "=", "(", "Class", "<", "?", "extends", "DataSource", ">", ")", "Class", ".", "forName", "(", "\"oracle.jdbc.pool.OracleDataSource\"", ")", ";", "DataSource", "dataSource", "=", "dataSourceClass", ".", "newInstance", "(", ")", ";", "dataSourceClass", ".", "getMethod", "(", "\"setURL\"", ",", "String", ".", "class", ")", ".", "invoke", "(", "dataSource", ",", "url", ")", ";", "dataSourceClass", ".", "getMethod", "(", "\"setUser\"", ",", "String", ".", "class", ")", ".", "invoke", "(", "dataSource", ",", "user", ")", ";", "dataSourceClass", ".", "getMethod", "(", "\"setPassword\"", ",", "String", ".", "class", ")", ".", "invoke", "(", "dataSource", ",", "password", ")", ";", "// OracleDataSource dataSource = new OracleDataSource();", "// dataSource.setURL(url);", "// dataSource.setUser(user);", "// dataSource.setPassword(password);", "return", "dataSource", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "LoggingRuntimeException", "(", "e", ",", "logger", ",", "\"Cannot connect to oracle db\"", ")", ";", "}", "}" ]

[ "Don", "t", "forget", "to", "add", "the", "dependency", "to", "ojdbc", "like", "this", "in", "your", "pom", ".", "xml", "<pre", ">", "&lt", ";", "dependency&gt", ";", "&lt", ";", "groupId&gt", ";", "com", ".", "oracle&lt", ";", "/", "groupId&gt", ";", "&lt", ";", "artifactId&gt", ";", "ojdbc7&lt", ";", "/", "artifactId&gt", ";", "&lt", ";", "version&gt", ";", "12", ".", "1", ".", "0", ".", "2&lt", ";", "/", "version&gt", ";", "&lt", ";", "scope&gt", ";", "provided&lt", ";", "/", "scope&gt", ";", "&lt", ";", "/", "dependency&gt", ";", "<", "/", "pre", ">" ]

[ "public", "void", "setConnectionProcessMap", "(", "Map", "<", "String", ",", "String", ">", "connectionProcessMap", ")", "throws", "RabbitmqCommunicateException", "{", "Map", "<", "String", ",", "String", ">", "tempConnectionProcessMap", "=", "connectionProcessMap", ";", "if", "(", "connectionProcessMap", "==", "null", ")", "{", "tempConnectionProcessMap", "=", "new", "HashMap", "<", "String", ",", "String", ">", "(", ")", ";", "}", "validateProcessReference", "(", "this", ".", "mqProcessList", ",", "tempConnectionProcessMap", ")", ";", "this", ".", "connectionProcessMap", "=", "tempConnectionProcessMap", ";", "}" ]

[ "呼出元別、接続先RabbitMQプロセスの定義マップを検証して設定する。" ]

[ "public", "static", "LongBinding", "subtractExact", "(", "final", "ObservableLongValue", "x", ",", "final", "ObservableLongValue", "y", ")", "{", "return", "createLongBinding", "(", "(", ")", "->", "Math", ".", "subtractExact", "(", "x", ".", "get", "(", ")", ",", "y", ".", "get", "(", ")", ")", ",", "x", ",", "y", ")", ";", "}" ]

[ "Binding", "for", "{", "@link", "java", ".", "lang", ".", "Math#subtractExact", "(", "long", "long", ")", "}" ]

[ "public", "int", "setBytes", "(", "final", "long", "pos", ",", "final", "byte", "[", "]", "bytes", ")", "throws", "SQLException", "{", "final", "int", "arrayPos", "=", "(", "int", ")", "pos", "-", "1", ";", "final", "int", "bytesWritten", ";", "if", "(", "blobContent", "==", "null", ")", "{", "this", ".", "blobContent", "=", "new", "byte", "[", "arrayPos", "+", "bytes", ".", "length", "]", ";", "bytesWritten", "=", "blobContent", ".", "length", ";", "this", ".", "actualSize", "=", "bytesWritten", ";", "}", "else", "if", "(", "blobContent", ".", "length", ">", "arrayPos", "+", "bytes", ".", "length", ")", "{", "bytesWritten", "=", "bytes", ".", "length", ";", "}", "else", "{", "blobContent", "=", "Utils", ".", "copyWithLength", "(", "blobContent", ",", "arrayPos", "+", "bytes", ".", "length", ")", ";", "actualSize", "=", "blobContent", ".", "length", ";", "bytesWritten", "=", "bytes", ".", "length", ";", "}", "System", ".", "arraycopy", "(", "bytes", ",", "0", ",", "this", ".", "blobContent", ",", "arrayPos", ",", "bytes", ".", "length", ")", ";", "return", "bytesWritten", ";", "}" ]

[ "Writes", "the", "given", "array", "of", "bytes", "to", "the", "<code", ">", "BLOB<", "/", "code", ">", "value", "that", "this", "<code", ">", "Blob<", "/", "code", ">", "object", "represents", "starting", "at", "position", "<code", ">", "pos<", "/", "code", ">", "and", "returns", "the", "number", "of", "bytes", "written", ".", "The", "array", "of", "bytes", "will", "overwrite", "the", "existing", "bytes", "in", "the", "<code", ">", "Blob<", "/", "code", ">", "object", "starting", "at", "the", "position", "<code", ">", "pos<", "/", "code", ">", ".", "If", "the", "end", "of", "the", "<code", ">", "Blob<", "/", "code", ">", "value", "is", "reached", "while", "writing", "the", "array", "of", "bytes", "then", "the", "length", "of", "the", "<code", ">", "Blob<", "/", "code", ">", "value", "will", "be", "increased", "to", "accomodate", "the", "extra", "bytes", ".", "<p", "/", ">", "<b", ">", "Note", ":", "<", "/", "b", ">", "If", "the", "value", "specified", "for", "<code", ">", "pos<", "/", "code", ">", "is", "greater", "then", "the", "length", "+", "1", "of", "the", "<code", ">", "BLOB<", "/", "code", ">", "value", "then", "the", "behavior", "is", "undefined", ".", "Some", "JDBC", "drivers", "may", "throw", "a", "<code", ">", "SQLException<", "/", "code", ">", "while", "other", "drivers", "may", "support", "this", "operation", "." ]

[ "private", "int", "findSpanStart", "(", "TextCursor", "cursor", ",", "int", "limit", ")", "{", "for", "(", "int", "i", "=", "cursor", ".", "currentOffset", ";", "i", "<", "limit", ";", "i", "++", ")", "{", "char", "c", "=", "cursor", ".", "text", ".", "charAt", "(", "i", ")", ";", "if", "(", "c", "==", "'", "'", "||", "c", "==", "'", "'", ")", "{", "// Check prev and next symbols", "if", "(", "isGoodAnchor", "(", "cursor", ".", "text", ",", "i", "-", "1", ")", "&&", "isNotSymbol", "(", "cursor", ".", "text", ",", "i", "+", "1", ",", "c", ")", ")", "{", "return", "i", ";", "}", "}", "}", "return", "-", "1", ";", "}" ]

[ "Searching", "for", "valid", "formatting", "span", "start" ]

[ "public", "double", "distance", "(", "Object", "pt1", ",", "Object", "pt2", ")", "{", "Object", "p", "=", "newCopy", "(", "pt1", ")", ";", "subtract", "(", "p", ",", "pt2", ")", ";", "return", "magnitude", "(", "p", ")", ";", "}" ]

[ "not", "used", "directly", "in", "algorithm", "but", "useful", "-", "override", "for", "good", "performance" ]

[ "public", "void", "ip_firewall_ipOnFirewall_PUT", "(", "String", "ip", ",", "String", "ipOnFirewall", ",", "OvhFirewallIp", "body", ")", "throws", "IOException", "{", "String", "qPath", "=", "\"/ip/{ip}/firewall/{ipOnFirewall}\"", ";", "StringBuilder", "sb", "=", "path", "(", "qPath", ",", "ip", ",", "ipOnFirewall", ")", ";", "exec", "(", "qPath", ",", "\"PUT\"", ",", "sb", ".", "toString", "(", ")", ",", "body", ")", ";", "}" ]

[ "Alter", "this", "object", "properties" ]

[ "public", "static", "String", "removeAllWhitespaces", "(", "final", "String", "string", ")", "{", "if", "(", "string", "==", "null", "||", "string", ".", "length", "(", ")", "==", "0", ")", "{", "return", "string", ";", "}", "final", "int", "originalSize", "=", "string", ".", "length", "(", ")", ";", "final", "char", "[", "]", "charArray", "=", "new", "char", "[", "originalSize", "]", ";", "int", "charCount", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "originalSize", ";", "i", "++", ")", "{", "final", "char", "currentChar", "=", "string", ".", "charAt", "(", "i", ")", ";", "if", "(", "!", "Character", ".", "isWhitespace", "(", "currentChar", ")", ")", "{", "charArray", "[", "charCount", "++", "]", "=", "currentChar", ";", "}", "}", "if", "(", "charCount", "==", "originalSize", ")", "{", "return", "string", ";", "}", "return", "new", "String", "(", "charArray", ",", "0", ",", "charCount", ")", ";", "}" ]

[ "<p", ">", "Internal", "utility", "method", ".", "DO", "NOT", "use", "this", "method", "directly", ".", "<", "/", "p", ">" ]

[ "public", "static", "BinaryExpression", "newAssignmentExpression", "(", "Variable", "variable", ",", "Expression", "rhs", ")", "{", "VariableExpression", "lhs", "=", "new", "VariableExpression", "(", "variable", ")", ";", "Token", "operator", "=", "Token", ".", "newPlaceholder", "(", "Types", ".", "ASSIGN", ")", ";", "return", "new", "BinaryExpression", "(", "lhs", ",", "operator", ",", "rhs", ")", ";", "}" ]

[ "Creates", "an", "assignment", "expression", "in", "which", "the", "specified", "expression", "is", "written", "into", "the", "specified", "variable", "name", "." ]

[ "public", "static", "Object", "getFieldValue", "(", "Object", "instance", ",", "String", "fieldName", ")", "{", "try", "{", "return", "PropertyUtils", ".", "getProperty", "(", "instance", ",", "fieldName", ")", ";", "}", "catch", "(", "IllegalAccessException", "|", "InvocationTargetException", "|", "NoSuchMethodException", "e", ")", "{", "JK", ".", "throww", "(", "e", ")", ";", "return", "null", ";", "}", "}" ]

[ "Gets", "the", "field", "value", "." ]

[ "public", "static", "ConceptId", "getResourceEdgeId", "(", "TransactionOLTP", "graph", ",", "ConceptId", "conceptId1", ",", "ConceptId", "conceptId2", ")", "{", "if", "(", "mayHaveResourceEdge", "(", "graph", ",", "conceptId1", ",", "conceptId2", ")", ")", "{", "Optional", "<", "Concept", ">", "firstConcept", "=", "graph", ".", "stream", "(", "Graql", ".", "match", "(", "var", "(", "\"x\"", ")", ".", "id", "(", "conceptId1", ".", "getValue", "(", ")", ")", ",", "var", "(", "\"y\"", ")", ".", "id", "(", "conceptId2", ".", "getValue", "(", ")", ")", ",", "var", "(", "\"z\"", ")", ".", "rel", "(", "var", "(", "\"x\"", ")", ")", ".", "rel", "(", "var", "(", "\"y\"", ")", ")", ")", ".", "get", "(", "\"z\"", ")", ")", ".", "map", "(", "answer", "->", "answer", ".", "get", "(", "\"z\"", ")", ")", ".", "findFirst", "(", ")", ";", "if", "(", "firstConcept", ".", "isPresent", "(", ")", ")", "{", "return", "firstConcept", ".", "get", "(", ")", ".", "id", "(", ")", ";", "}", "}", "return", "null", ";", "}" ]

[ "Get", "the", "resource", "edge", "id", "if", "there", "is", "one", ".", "Return", "null", "if", "not", "." ]

[ "protected", "boolean", "isDelegatedClientAuthorizedForService", "(", "final", "Client", "client", ",", "final", "Service", "service", ")", "{", "if", "(", "service", "==", "null", "||", "StringUtils", ".", "isBlank", "(", "service", ".", "getId", "(", ")", ")", ")", "{", "LOGGER", ".", "debug", "(", "\"Can not evaluate delegated authentication policy since no service was provided in the request while processing client [{}]\"", ",", "client", ")", ";", "return", "true", ";", "}", "val", "registeredService", "=", "this", ".", "servicesManager", ".", "findServiceBy", "(", "service", ")", ";", "if", "(", "registeredService", "==", "null", "||", "!", "registeredService", ".", "getAccessStrategy", "(", ")", ".", "isServiceAccessAllowed", "(", ")", ")", "{", "LOGGER", ".", "warn", "(", "\"Service access for [{}] is denied\"", ",", "registeredService", ")", ";", "return", "false", ";", "}", "LOGGER", ".", "trace", "(", "\"Located registered service definition [{}] matching [{}]\"", ",", "registeredService", ",", "service", ")", ";", "val", "context", "=", "AuditableContext", ".", "builder", "(", ")", ".", "registeredService", "(", "registeredService", ")", ".", "properties", "(", "CollectionUtils", ".", "wrap", "(", "Client", ".", "class", ".", "getSimpleName", "(", ")", ",", "client", ".", "getName", "(", ")", ")", ")", ".", "build", "(", ")", ";", "val", "result", "=", "delegatedAuthenticationPolicyEnforcer", ".", "execute", "(", "context", ")", ";", "if", "(", "!", "result", ".", "isExecutionFailure", "(", ")", ")", "{", "LOGGER", ".", "debug", "(", "\"Delegated authentication policy for [{}] allows for using client [{}]\"", ",", "registeredService", ",", "client", ")", ";", "return", "true", ";", "}", "LOGGER", ".", "warn", "(", "\"Delegated authentication policy for [{}] refuses access to client [{}]\"", ",", "registeredService", ".", "getServiceId", "(", ")", ",", "client", ")", ";", "return", "false", ";", "}" ]

[ "Is", "delegated", "client", "authorized", "for", "service", "boolean", "." ]

[ "private", "String", "renderDefaultJavaScript", "(", "HttpServletRequest", "request", ",", "String", "realId", ")", "{", "String", "idScript", "=", "null", ";", "// map the tagId to the real id", "if", "(", "TagConfig", ".", "isDefaultJavaScript", "(", ")", ")", "{", "ScriptRequestState", "srs", "=", "ScriptRequestState", ".", "getScriptRequestState", "(", "request", ")", ";", "idScript", "=", "srs", ".", "mapTagId", "(", "getScriptReporter", "(", ")", ",", "_trs", ".", "tagId", ",", "realId", ",", "null", ")", ";", "}", "return", "idScript", ";", "}" ]

[ "Much", "of", "the", "code", "below", "is", "taken", "from", "the", "HtmlBaseTag", ".", "We", "need", "to", "eliminate", "this", "duplication", "through", "some", "type", "of", "helper", "methods", "." ]

[ "public", "void", "notifyCheckpointComplete", "(", "long", "checkpointId", ",", "long", "timestamp", ")", "{", "final", "LogicalSlot", "slot", "=", "assignedResource", ";", "if", "(", "slot", "!=", "null", ")", "{", "final", "TaskManagerGateway", "taskManagerGateway", "=", "slot", ".", "getTaskManagerGateway", "(", ")", ";", "taskManagerGateway", ".", "notifyCheckpointComplete", "(", "attemptId", ",", "getVertex", "(", ")", ".", "getJobId", "(", ")", ",", "checkpointId", ",", "timestamp", ")", ";", "}", "else", "{", "LOG", ".", "debug", "(", "\"The execution has no slot assigned. This indicates that the execution is \"", "+", "\"no longer running.\"", ")", ";", "}", "}" ]

[ "Notify", "the", "task", "of", "this", "execution", "about", "a", "completed", "checkpoint", "." ]

[ "public", "void", "registerThrowable", "(", "RetryContext", "context", ",", "Throwable", "throwable", ")", "{", "(", "(", "NeverRetryContext", ")", "context", ")", ".", "setFinished", "(", ")", ";", "(", "(", "RetryContextSupport", ")", "context", ")", ".", "registerThrowable", "(", "throwable", ")", ";", "}" ]

[ "Make", "the", "throwable", "available", "for", "downstream", "use", "through", "the", "context", "." ]

[ "public", "Observable", "<", "VpnSiteInner", ">", "beginUpdateTagsAsync", "(", "String", "resourceGroupName", ",", "String", "vpnSiteName", ",", "Map", "<", "String", ",", "String", ">", "tags", ")", "{", "return", "beginUpdateTagsWithServiceResponseAsync", "(", "resourceGroupName", ",", "vpnSiteName", ",", "tags", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "VpnSiteInner", ">", ",", "VpnSiteInner", ">", "(", ")", "{", "@", "Override", "public", "VpnSiteInner", "call", "(", "ServiceResponse", "<", "VpnSiteInner", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Updates", "VpnSite", "tags", "." ]

[ "private", "ServerHandle", "detectServers", "(", "List", "<", "ServerDetector", ">", "pDetectors", ",", "LogHandler", "pLogHandler", ")", "{", "// Now detect the server", "for", "(", "ServerDetector", "detector", ":", "pDetectors", ")", "{", "try", "{", "ServerHandle", "info", "=", "detector", ".", "detect", "(", "mBeanServerManager", ")", ";", "if", "(", "info", "!=", "null", ")", "{", "return", "info", ";", "}", "}", "catch", "(", "Exception", "exp", ")", "{", "// We are defensive here and wont stop the servlet because", "// there is a problem with the server detection. A error will be logged", "// nevertheless, though.", "pLogHandler", ".", "error", "(", "\"Error while using detector \"", "+", "detector", ".", "getClass", "(", ")", ".", "getSimpleName", "(", ")", "+", "\": \"", "+", "exp", ",", "exp", ")", ";", "}", "}", "return", "null", ";", "}" ]

[ "by", "a", "lookup", "mechanism", "queried", "and", "thrown", "away", "after", "this", "method" ]

[ "public", "static", "int", "getImmediateScanJobId", "(", "Context", "context", ")", "{", "if", "(", "sOverrideImmediateScanJobId", ">=", "0", ")", "{", "LogManager", ".", "i", "(", "TAG", ",", "\"Using ImmediateScanJobId from static override: \"", "+", "sOverrideImmediateScanJobId", ")", ";", "return", "sOverrideImmediateScanJobId", ";", "}", "return", "getJobIdFromManifest", "(", "context", ",", "\"immediateScanJobId\"", ")", ";", "}" ]

[ "Returns", "the", "job", "id", "to", "be", "used", "to", "schedule", "this", "job", ".", "This", "may", "be", "set", "in", "the", "AndroidManifest", ".", "xml", "or", "in", "single", "process", "applications", "by", "using", "#setOverrideJobId" ]

[ "public", "Document", "createRaw", "(", "@", "NonNull", "String", "id", ",", "@", "NonNull", "String", "content", ")", "{", "return", "createRaw", "(", "id", ",", "content", ",", "defaultLanguage", ",", "Collections", ".", "emptyMap", "(", ")", ")", ";", "}" ]

[ "Creates", "a", "document", "with", "the", "given", "id", "and", "content", "written", "in", "the", "default", "language", ".", "This", "method", "does", "not", "apply", "any", "{", "@link", "TextNormalizer", "}" ]

[ "public", "DateDue", "setDateDue", "(", "Date", "dateDue", ",", "boolean", "hasTime", ")", "{", "DateDue", "prop", "=", "(", "dateDue", "==", "null", ")", "?", "null", ":", "new", "DateDue", "(", "dateDue", ",", "hasTime", ")", ";", "setDateDue", "(", "prop", ")", ";", "return", "prop", ";", "}" ]

[ "Sets", "the", "date", "that", "a", "to", "-", "do", "task", "is", "due", "by", ".", "This", "must", "NOT", "be", "set", "if", "a", "{" ]

[ "public", "void", "closeReaderOrWriter", "(", "long", "sessionId", ",", "long", "blockId", ")", "throws", "IOException", "{", "BlockInfo", "blockInfo", ";", "try", "(", "LockResource", "lr", "=", "new", "LockResource", "(", "mLock", ")", ")", "{", "blockInfo", "=", "mBlocks", ".", "get", "(", "new", "Key", "(", "sessionId", ",", "blockId", ")", ")", ";", "if", "(", "blockInfo", "==", "null", ")", "{", "LOG", ".", "warn", "(", "\"Key (block ID: {}, session ID {}) is not found when cleaning up the UFS block.\"", ",", "blockId", ",", "sessionId", ")", ";", "return", ";", "}", "}", "blockInfo", ".", "closeReaderOrWriter", "(", ")", ";", "}" ]

[ "Closes", "the", "block", "reader", "or", "writer", "and", "checks", "whether", "it", "is", "necessary", "to", "commit", "the", "block", "to", "Local", "block", "store", "." ]

[ "public", "OvhRegion", "project_serviceName_region_POST", "(", "String", "serviceName", ",", "String", "region", ")", "throws", "IOException", "{", "String", "qPath", "=", "\"/cloud/project/{serviceName}/region\"", ";", "StringBuilder", "sb", "=", "path", "(", "qPath", ",", "serviceName", ")", ";", "HashMap", "<", "String", ",", "Object", ">", "o", "=", "new", "HashMap", "<", "String", ",", "Object", ">", "(", ")", ";", "addBody", "(", "o", ",", "\"region\"", ",", "region", ")", ";", "String", "resp", "=", "exec", "(", "qPath", ",", "\"POST\"", ",", "sb", ".", "toString", "(", ")", ",", "o", ")", ";", "return", "convertTo", "(", "resp", ",", "OvhRegion", ".", "class", ")", ";", "}" ]

[ "Request", "access", "to", "a", "region" ]

[ "public", "Postcard", "withParcelable", "(", "@", "Nullable", "String", "key", ",", "@", "Nullable", "Parcelable", "value", ")", "{", "mBundle", ".", "putParcelable", "(", "key", ",", "value", ")", ";", "return", "this", ";", "}" ]

[ "Inserts", "a", "Parcelable", "value", "into", "the", "mapping", "of", "this", "Bundle", "replacing", "any", "existing", "value", "for", "the", "given", "key", ".", "Either", "key", "or", "value", "may", "be", "null", "." ]

[ "@", "Override", "public", "void", "removeByG_A", "(", "long", "groupId", ",", "boolean", "active", ")", "{", "for", "(", "CommerceTaxMethod", "commerceTaxMethod", ":", "findByG_A", "(", "groupId", ",", "active", ",", "QueryUtil", ".", "ALL_POS", ",", "QueryUtil", ".", "ALL_POS", ",", "null", ")", ")", "{", "remove", "(", "commerceTaxMethod", ")", ";", "}", "}" ]

[ "Removes", "all", "the", "commerce", "tax", "methods", "where", "groupId", "=", "&#63", ";", "and", "active", "=", "&#63", ";", "from", "the", "database", "." ]

[ "public", "static", "NestableFieldValidator", "mapFv", "(", "Class", "key", ",", "Class", "val", ",", "boolean", "nullAllowed", ")", "{", "return", "mapFv", "(", "fv", "(", "key", ",", "false", ")", ",", "fv", "(", "val", ",", "false", ")", ",", "nullAllowed", ")", ";", "}" ]

[ "Returns", "a", "new", "NestableFieldValidator", "for", "a", "Map", "of", "key", "to", "val", "." ]

[ "@", "Override", "public", "List", "<", "CommerceNotificationTemplate", ">", "findAll", "(", "int", "start", ",", "int", "end", ")", "{", "return", "findAll", "(", "start", ",", "end", ",", "null", ")", ";", "}" ]

[ "Returns", "a", "range", "of", "all", "the", "commerce", "notification", "templates", "." ]

[ "@", "Override", "public", "Optional", "<", "File", ">", "which", "(", "Iterable", "<", "String", ">", "filenames", ")", "{", "for", "(", "File", "parent", ":", "ImmutableList", ".", "copyOf", "(", "parents", ")", ")", "{", "for", "(", "String", "filename", ":", "filenames", ")", "{", "Iterable", "<", "String", ">", "filenameVariations", "=", "transform", ".", "apply", "(", "filename", ")", ";", "for", "(", "String", "filenameVariation", ":", "filenameVariations", ")", "{", "File", "file", "=", "new", "File", "(", "parent", ",", "filenameVariation", ")", ";", "if", "(", "isValidResult", "(", "file", ")", ")", "{", "return", "Optional", ".", "of", "(", "file", ")", ";", "}", "}", "}", "}", "return", "Optional", ".", "empty", "(", ")", ";", "}" ]

[ "Returns", "the", "{" ]

[ "public", "<", "S", "extends", "Model", ">", "int", "updateById", "(", "S", "model", ",", "Serializable", "id", ")", "{", "this", ".", "where", "(", "primaryKeyColumn", ",", "id", ")", ";", "String", "sql", "=", "this", ".", "buildUpdateSQL", "(", "model", ",", "null", ")", ";", "List", "<", "Object", ">", "columnValueList", "=", "AnimaUtils", ".", "toColumnValues", "(", "model", ",", "false", ")", ";", "columnValueList", ".", "add", "(", "id", ")", ";", "return", "this", ".", "execute", "(", "sql", ",", "columnValueList", ")", ";", "}" ]

[ "Update", "model", "by", "primary", "key" ]

[ "public", "static", "HttpResponse", "executeGet", "(", "final", "String", "url", ")", "{", "try", "{", "return", "executeGet", "(", "url", ",", "null", ",", "null", ",", "new", "LinkedHashMap", "<>", "(", ")", ")", ";", "}", "catch", "(", "final", "Exception", "e", ")", "{", "LOGGER", ".", "error", "(", "e", ".", "getMessage", "(", ")", ",", "e", ")", ";", "}", "return", "null", ";", "}" ]

[ "Execute", "get", "http", "response", "." ]

[ "public", "double", "[", "]", "applyInverse", "(", "double", "[", "]", "v", ")", "{", "if", "(", "inv", "==", "null", ")", "{", "updateInverse", "(", ")", ";", "}", "return", "unhomogeneVector", "(", "times", "(", "inv", ",", "homogeneVector", "(", "v", ")", ")", ")", ";", "}" ]

[ "Apply", "the", "inverse", "transformation", "onto", "a", "vector" ]

[ "public", "static", "JulianDay", "ofSimplifiedTime", "(", "Moment", "moment", ")", "{", "return", "new", "JulianDay", "(", "getValue", "(", "moment", ",", "TimeScale", ".", "POSIX", ")", ",", "TimeScale", ".", "POSIX", ")", ";", "}" ]

[ "/", "*", "[", "deutsch", "]", "<p", ">", "Erzeugt", "einen", "julianischen", "Tag", "auf", "der", "Zeitskala", "{", "@link", "TimeScale#POSIX", "}", ".", "<", "/", "p", ">" ]

[ "public", "int", "unpackBinaryHeader", "(", ")", "throws", "IOException", "{", "byte", "b", "=", "readByte", "(", ")", ";", "if", "(", "Code", ".", "isFixedRaw", "(", "b", ")", ")", "{", "// FixRaw", "return", "b", "&", "0x1f", ";", "}", "int", "len", "=", "tryReadBinaryHeader", "(", "b", ")", ";", "if", "(", "len", ">=", "0", ")", "{", "return", "len", ";", "}", "if", "(", "allowReadingStringAsBinary", ")", "{", "len", "=", "tryReadStringHeader", "(", "b", ")", ";", "if", "(", "len", ">=", "0", ")", "{", "return", "len", ";", "}", "}", "throw", "unexpected", "(", "\"Binary\"", ",", "b", ")", ";", "}" ]

[ "Reads", "header", "of", "a", "binary", "." ]

[ "public", "static", "NodeList", "toNodeList", "(", "Object", "o", ")", "throws", "PageException", "{", "// print.ln(\"nodeList:\"+o);", "if", "(", "o", "instanceof", "NodeList", ")", "{", "return", "(", "NodeList", ")", "o", ";", "}", "else", "if", "(", "o", "instanceof", "ObjectWrap", ")", "{", "return", "toNodeList", "(", "(", "(", "ObjectWrap", ")", "o", ")", ".", "getEmbededObject", "(", ")", ")", ";", "}", "throw", "new", "CasterException", "(", "o", ",", "\"NodeList\"", ")", ";", "}" ]

[ "casts", "a", "Object", "to", "a", "Node", "List" ]

[ "private", "void", "buildDeprecatedSection", "(", "MarkupDocBuilder", "markupDocBuilder", ",", "PathOperation", "operation", ")", "{", "if", "(", "BooleanUtils", ".", "isTrue", "(", "operation", ".", "getOperation", "(", ")", ".", "isDeprecated", "(", ")", ")", ")", "{", "markupDocBuilder", ".", "block", "(", "DEPRECATED_OPERATION", ",", "MarkupBlockStyle", ".", "EXAMPLE", ",", "null", ",", "MarkupAdmonition", ".", "CAUTION", ")", ";", "}", "}" ]

[ "Builds", "a", "warning", "if", "method", "is", "deprecated", "." ]

[ "private", "static", "void", "addDependency", "(", "List", "<", "Dependency", ">", "dependencies", ",", "MavenCoordinates", "requiredArtifact", ",", "Constants", ".", "ArtifactType", "type", ",", "String", "scope", ")", "{", "Dependency", "dependency", "=", "new", "Dependency", "(", ")", ";", "dependency", ".", "setGroupId", "(", "requiredArtifact", ".", "getGroupId", "(", ")", ")", ";", "dependency", ".", "setArtifactId", "(", "requiredArtifact", ".", "getArtifactId", "(", ")", ")", ";", "dependency", ".", "setVersion", "(", "requiredArtifact", ".", "getVersion", "(", ")", ")", ";", "if", "(", "scope", "!=", "null", ")", "{", "dependency", ".", "setScope", "(", "scope", ")", ";", "}", "if", "(", "type", "!=", "null", ")", "{", "dependency", ".", "setType", "(", "type", ".", "getType", "(", ")", ")", ";", "}", "dependencies", ".", "add", "(", "dependency", ")", ";", "}" ]

[ "Add", "dependency", "to", "the", "list", "of", "Maven", "Dependencies", "." ]

[ "public", "static", "int", "murmurhash3x8632", "(", "byte", "[", "]", "data", ",", "int", "offset", ",", "int", "len", ",", "int", "seed", ")", "{", "int", "c1", "=", "0xcc9e2d51", ";", "int", "c2", "=", "0x1b873593", ";", "int", "h1", "=", "seed", ";", "int", "roundedEnd", "=", "offset", "+", "(", "len", "&", "0xfffffffc", ")", ";", "// round down to 4 byte block", "for", "(", "int", "i", "=", "offset", ";", "i", "<", "roundedEnd", ";", "i", "+=", "4", ")", "{", "// little endian load order", "int", "k1", "=", "(", "data", "[", "i", "]", "&", "0xff", ")", "|", "(", "(", "data", "[", "i", "+", "1", "]", "&", "0xff", ")", "<<", "8", ")", "|", "(", "(", "data", "[", "i", "+", "2", "]", "&", "0xff", ")", "<<", "16", ")", "|", "(", "data", "[", "i", "+", "3", "]", "<<", "24", ")", ";", "k1", "*=", "c1", ";", "k1", "=", "(", "k1", "<<", "15", ")", "|", "(", "k1", ">>>", "17", ")", ";", "// ROTL32(k1,15);", "k1", "*=", "c2", ";", "h1", "^=", "k1", ";", "h1", "=", "(", "h1", "<<", "13", ")", "|", "(", "h1", ">>>", "19", ")", ";", "// ROTL32(h1,13);", "h1", "=", "h1", "*", "5", "+", "0xe6546b64", ";", "}", "// tail", "int", "k1", "=", "0", ";", "switch", "(", "len", "&", "0x03", ")", "{", "case", "3", ":", "k1", "=", "(", "data", "[", "roundedEnd", "+", "2", "]", "&", "0xff", ")", "<<", "16", ";", "// fallthrough", "case", "2", ":", "k1", "|=", "(", "data", "[", "roundedEnd", "+", "1", "]", "&", "0xff", ")", "<<", "8", ";", "// fallthrough", "case", "1", ":", "k1", "|=", "data", "[", "roundedEnd", "]", "&", "0xff", ";", "k1", "*=", "c1", ";", "k1", "=", "(", "k1", "<<", "15", ")", "|", "(", "k1", ">>>", "17", ")", ";", "// ROTL32(k1,15);", "k1", "*=", "c2", ";", "h1", "^=", "k1", ";", "default", ":", "}", "// finalization", "h1", "^=", "len", ";", "// fmix(h1);", "h1", "^=", "h1", ">>>", "16", ";", "h1", "*=", "0x85ebca6b", ";", "h1", "^=", "h1", ">>>", "13", ";", "h1", "*=", "0xc2b2ae35", ";", "h1", "^=", "h1", ">>>", "16", ";", "return", "h1", ";", "}" ]

[ "This", "code", "is", "public", "domain", "." ]

[ "public", "String", "getResponseHeaderValue", "(", "String", "name", ",", "String", "defaultVal", ")", "{", "if", "(", "m_response", ".", "containsHeader", "(", "name", ")", ")", "{", "return", "m_response", ".", "getFirstHeader", "(", "name", ")", ".", "getValue", "(", ")", ";", "}", "else", "{", "return", "defaultVal", ";", "}", "}" ]

[ "Return", "the", "first", "value", "of", "a", "header", "or", "the", "default", "if", "the", "fighter", "is", "not", "present" ]

[ "@", "Deprecated", "public", "ProxySelector", "getOriginalProxySelector", "(", ")", "{", "return", "new", "ProxySelector", "(", ")", "{", "@", "Override", "public", "List", "<", "Proxy", ">", "select", "(", "URI", "uri", ")", "{", "InetSocketAddress", "address", "=", "originalProxies", ".", "get", "(", "uri", ".", "getScheme", "(", ")", ")", ";", "if", "(", "address", "!=", "null", "&&", "!", "(", "originalNonProxyHosts", ".", "contains", "(", "uri", ".", "getHost", "(", ")", ")", ")", ")", "{", "return", "Collections", ".", "singletonList", "(", "new", "Proxy", "(", "HTTP", ",", "address", ")", ")", ";", "}", "else", "{", "return", "Collections", ".", "singletonList", "(", "Proxy", ".", "NO_PROXY", ")", ";", "}", "}", "@", "Override", "public", "void", "connectFailed", "(", "URI", "uri", ",", "SocketAddress", "sa", ",", "IOException", "ioe", ")", "{", "}", "}", ";", "}" ]

[ "Used", "by", "the", "Betamax", "proxy", "so", "that", "it", "can", "use", "pre", "-", "existing", "proxy", "settings", "when", "forwarding", "requests", "that", "do", "not", "match", "anything", "on", "tape", "." ]

[ "public", "static", "String", "encryptByAES", "(", "final", "String", "content", ",", "final", "String", "key", ")", "{", "try", "{", "final", "KeyGenerator", "kgen", "=", "KeyGenerator", ".", "getInstance", "(", "\"AES\"", ")", ";", "final", "SecureRandom", "secureRandom", "=", "SecureRandom", ".", "getInstance", "(", "\"SHA1PRNG\"", ")", ";", "secureRandom", ".", "setSeed", "(", "key", ".", "getBytes", "(", ")", ")", ";", "kgen", ".", "init", "(", "128", ",", "secureRandom", ")", ";", "final", "SecretKey", "secretKey", "=", "kgen", ".", "generateKey", "(", ")", ";", "final", "byte", "[", "]", "enCodeFormat", "=", "secretKey", ".", "getEncoded", "(", ")", ";", "final", "SecretKeySpec", "keySpec", "=", "new", "SecretKeySpec", "(", "enCodeFormat", ",", "\"AES\"", ")", ";", "final", "Cipher", "cipher", "=", "Cipher", ".", "getInstance", "(", "\"AES\"", ")", ";", "final", "byte", "[", "]", "byteContent", "=", "content", ".", "getBytes", "(", "\"UTF-8\"", ")", ";", "cipher", ".", "init", "(", "Cipher", ".", "ENCRYPT_MODE", ",", "keySpec", ")", ";", "final", "byte", "[", "]", "result", "=", "cipher", ".", "doFinal", "(", "byteContent", ")", ";", "return", "Hex", ".", "encodeHexString", "(", "result", ")", ";", "}", "catch", "(", "final", "Exception", "e", ")", "{", "LOGGER", ".", "log", "(", "Level", ".", "WARN", ",", "\"Encrypt failed\"", ",", "e", ")", ";", "return", "null", ";", "}", "}" ]

[ "Encrypts", "by", "AES", "." ]

[ "public", "void", "setPresence", "(", "Object", "newPresence", ",", "final", "Respoke", ".", "TaskCompletionListener", "completionListener", ")", "{", "if", "(", "isConnected", "(", ")", ")", "{", "Object", "presenceToSet", "=", "newPresence", ";", "if", "(", "null", "==", "presenceToSet", ")", "{", "presenceToSet", "=", "\"available\"", ";", "}", "JSONObject", "typeData", "=", "new", "JSONObject", "(", ")", ";", "JSONObject", "data", "=", "new", "JSONObject", "(", ")", ";", "try", "{", "typeData", ".", "put", "(", "\"type\"", ",", "presenceToSet", ")", ";", "data", ".", "put", "(", "\"presence\"", ",", "typeData", ")", ";", "final", "Object", "finalPresence", "=", "presenceToSet", ";", "signalingChannel", ".", "sendRESTMessage", "(", "\"post\"", ",", "\"/v1/presence\"", ",", "data", ",", "new", "RespokeSignalingChannel", ".", "RESTListener", "(", ")", "{", "@", "Override", "public", "void", "onSuccess", "(", "Object", "response", ")", "{", "presence", "=", "finalPresence", ";", "Respoke", ".", "postTaskSuccess", "(", "completionListener", ")", ";", "}", "@", "Override", "public", "void", "onError", "(", "final", "String", "errorMessage", ")", "{", "Respoke", ".", "postTaskError", "(", "completionListener", ",", "errorMessage", ")", ";", "}", "}", ")", ";", "}", "catch", "(", "JSONException", "e", ")", "{", "Respoke", ".", "postTaskError", "(", "completionListener", ",", "\"Error encoding presence to json\"", ")", ";", "}", "}", "else", "{", "Respoke", ".", "postTaskError", "(", "completionListener", ",", "\"Can't complete request when not connected. Please reconnect!\"", ")", ";", "}", "}" ]

[ "Set", "the", "presence", "on", "the", "client", "session" ]

[ "protected", "int", "countToken", "(", "String", "token", ",", "String", "target", ")", "{", "int", "tokenIndex", "=", "0", ";", "int", "count", "=", "0", ";", "while", "(", "tokenIndex", "!=", "-", "1", ")", "{", "tokenIndex", "=", "target", ".", "indexOf", "(", "token", ",", "tokenIndex", ")", ";", "if", "(", "tokenIndex", ">", "-", "1", ")", "{", "tokenIndex", "++", ";", "count", "++", ";", "}", "}", "return", "count", ";", "}" ]

[ "Returns", "the", "number", "of", "times", "the", "token", "appears", "in", "the", "target", "." ]

[ "private", "OmemoCachedDeviceList", "removeStaleDevicesFromDeviceList", "(", "OmemoDevice", "userDevice", ",", "BareJid", "contact", ",", "OmemoCachedDeviceList", "contactsDeviceList", ",", "int", "maxAgeHours", ")", "{", "OmemoCachedDeviceList", "deviceList", "=", "new", "OmemoCachedDeviceList", "(", "contactsDeviceList", ")", ";", "// Don't work on original list.", "// Iterate through original list, but modify copy instead", "for", "(", "int", "deviceId", ":", "contactsDeviceList", ".", "getActiveDevices", "(", ")", ")", "{", "OmemoDevice", "device", "=", "new", "OmemoDevice", "(", "contact", ",", "deviceId", ")", ";", "Date", "lastDeviceIdPublication", "=", "getOmemoStoreBackend", "(", ")", ".", "getDateOfLastDeviceIdPublication", "(", "userDevice", ",", "device", ")", ";", "if", "(", "lastDeviceIdPublication", "==", "null", ")", "{", "lastDeviceIdPublication", "=", "new", "Date", "(", ")", ";", "getOmemoStoreBackend", "(", ")", ".", "setDateOfLastDeviceIdPublication", "(", "userDevice", ",", "device", ",", "lastDeviceIdPublication", ")", ";", "}", "Date", "lastMessageReceived", "=", "getOmemoStoreBackend", "(", ")", ".", "getDateOfLastReceivedMessage", "(", "userDevice", ",", "device", ")", ";", "if", "(", "lastMessageReceived", "==", "null", ")", "{", "lastMessageReceived", "=", "new", "Date", "(", ")", ";", "getOmemoStoreBackend", "(", ")", ".", "setDateOfLastReceivedMessage", "(", "userDevice", ",", "device", ",", "lastMessageReceived", ")", ";", "}", "boolean", "stale", "=", "isStale", "(", "userDevice", ",", "device", ",", "lastDeviceIdPublication", ",", "maxAgeHours", ")", ";", "stale", "&=", "isStale", "(", "userDevice", ",", "device", ",", "lastMessageReceived", ",", "maxAgeHours", ")", ";", "if", "(", "stale", ")", "{", "deviceList", ".", "addInactiveDevice", "(", "deviceId", ")", ";", "}", "}", "return", "deviceList", ";", "}" ]

[ "Return", "a", "copy", "of", "the", "given", "deviceList", "of", "user", "contact", "but", "with", "stale", "devices", "marked", "as", "inactive", ".", "Never", "mark", "our", "own", "device", "as", "stale", ".", "If", "we", "haven", "t", "yet", "received", "a", "message", "from", "a", "device", "store", "the", "current", "date", "as", "last", "date", "of", "message", "receipt", "to", "allow", "future", "decisions", "." ]

[ "private", "void", "writeByteBufferSerdeHeader", "(", "ByteBuffer", "buf", ",", "byte", "mode", ")", "{", "buf", ".", "put", "(", "SERIALIZATION_VERSION", ")", ";", "buf", ".", "put", "(", "mode", ")", ";", "}" ]

[ "Write", "a", "serialization", "header", "containing", "the", "serde", "version", "byte", "and", "full", "/", "sparse", "encoding", "mode", "byte", "." ]

[ "public", "void", "insertContextMenu", "(", "List", "<", "CmsContextMenuEntryBean", ">", "menuBeans", ",", "CmsUUID", "structureId", ")", "{", "List", "<", "I_CmsContextMenuEntry", ">", "menuEntries", "=", "transformEntries", "(", "menuBeans", ",", "structureId", ")", ";", "m_editor", ".", "getContext", "(", ")", ".", "showMenu", "(", "menuEntries", ")", ";", "}" ]

[ "Inserts", "the", "context", "menu", ".", "<p", ">" ]

[ "public", "final", "void", "splitTo", "(", "AbstractNode", "<", "E", ">", "newNode", ",", "List", "<", "E", ">", "assignmentsToFirst", ",", "List", "<", "E", ">", "assignmentsToSecond", ")", "{", "assert", "(", "isLeaf", "(", ")", "==", "newNode", ".", "isLeaf", "(", ")", ")", ";", "deleteAllEntries", "(", ")", ";", "StringBuilder", "msg", "=", "LoggingConfiguration", ".", "DEBUG", "?", "new", "StringBuilder", "(", "1000", ")", ":", "null", ";", "// assignments to this node", "for", "(", "E", "entry", ":", "assignmentsToFirst", ")", "{", "if", "(", "msg", "!=", "null", ")", "{", "msg", ".", "append", "(", "\"n_\"", ")", ".", "append", "(", "getPageID", "(", ")", ")", ".", "append", "(", "'", "'", ")", ".", "append", "(", "entry", ")", ".", "append", "(", "'", "'", ")", ";", "}", "addEntry", "(", "entry", ")", ";", "}", "// assignments to the new node", "for", "(", "E", "entry", ":", "assignmentsToSecond", ")", "{", "if", "(", "msg", "!=", "null", ")", "{", "msg", ".", "append", "(", "\"n_\"", ")", ".", "append", "(", "newNode", ".", "getPageID", "(", ")", ")", ".", "append", "(", "'", "'", ")", ".", "append", "(", "entry", ")", ".", "append", "(", "'", "'", ")", ";", "}", "newNode", ".", "addEntry", "(", "entry", ")", ";", "}", "if", "(", "msg", "!=", "null", ")", "{", "Logging", ".", "getLogger", "(", "this", ".", "getClass", "(", ")", ")", ".", "fine", "(", "msg", ".", "toString", "(", ")", ")", ";", "}", "}" ]

[ "Splits", "the", "entries", "of", "this", "node", "into", "a", "new", "node", "using", "the", "given", "assignments" ]

[ "public", "static", "String", "buildQuery", "(", "Map", "<", "String", ",", "String", ">", "entries", ",", "String", "encoding", ")", "throws", "FoxHttpRequestException", "{", "if", "(", "entries", ".", "size", "(", ")", ">", "0", ")", "{", "StringBuilder", "sb", "=", "new", "StringBuilder", "(", ")", ";", "String", "dataString", ";", "try", "{", "for", "(", "Map", ".", "Entry", "<", "String", ",", "String", ">", "entry", ":", "entries", ".", "entrySet", "(", ")", ")", "{", "sb", ".", "append", "(", "URLEncoder", ".", "encode", "(", "entry", ".", "getKey", "(", ")", ",", "encoding", ")", ")", ";", "sb", ".", "append", "(", "\"=\"", ")", ";", "sb", ".", "append", "(", "URLEncoder", ".", "encode", "(", "entry", ".", "getValue", "(", ")", ",", "encoding", ")", ")", ";", "sb", ".", "append", "(", "\"&\"", ")", ";", "}", "sb", ".", "deleteCharAt", "(", "sb", ".", "lastIndexOf", "(", "\"&\"", ")", ")", ";", "dataString", "=", "sb", ".", "toString", "(", ")", ";", "}", "catch", "(", "UnsupportedEncodingException", "e", ")", "{", "throw", "new", "FoxHttpRequestException", "(", "e", ")", ";", "}", "return", "dataString", ";", "}", "else", "{", "return", "\"\"", ";", "}", "}" ]

[ "Return", "a", "string", "of", "key", "/", "value", "pair", "s", "based", "on", "a", "map" ]

[ "protected", "void", "checkRequired", "(", "String", "key", ",", "AnnotatedElement", "element", ")", "{", "if", "(", "isRequired", "(", "element", ")", ")", "{", "throw", "new", "PropertyLoaderException", "(", "String", ".", "format", "(", "\"Required property <%s> doesn't exists\"", ",", "key", ")", ")", ";", "}", "}" ]

[ "Throws", "an", "exception", "if", "given", "element", "is", "required", "." ]

[ "@", "Pure", "public", "static", "SpaceUnit", "getSmallestUnit", "(", "double", "amount", ",", "SpaceUnit", "unit", ")", "{", "final", "double", "meters", "=", "toMeters", "(", "amount", ",", "unit", ")", ";", "double", "v", ";", "final", "SpaceUnit", "[", "]", "units", "=", "SpaceUnit", ".", "values", "(", ")", ";", "SpaceUnit", "u", ";", "for", "(", "int", "i", "=", "units", ".", "length", "-", "1", ";", "i", ">=", "0", ";", "--", "i", ")", "{", "u", "=", "units", "[", "i", "]", ";", "v", "=", "Math", ".", "floor", "(", "fromMeters", "(", "meters", ",", "u", ")", ")", ";", "if", "(", "v", ">", "0.", ")", "{", "return", "u", ";", "}", "}", "return", "unit", ";", "}" ]

[ "Compute", "the", "smallest", "unit", "that", "permits", "to", "have", "a", "metric", "value", "with", "its", "integer", "part", "positive", "." ]

[ "private", "void", "buildIndex", "(", "CveDB", "cve", ")", "throws", "IndexException", "{", "try", "(", "Analyzer", "analyzer", "=", "createSearchingAnalyzer", "(", ")", ";", "IndexWriter", "indexWriter", "=", "new", "IndexWriter", "(", "index", ",", "new", "IndexWriterConfig", "(", "analyzer", ")", ")", ")", "{", "final", "FieldType", "ft", "=", "new", "FieldType", "(", "TextField", ".", "TYPE_STORED", ")", ";", "//ignore term frequency", "ft", ".", "setIndexOptions", "(", "IndexOptions", ".", "DOCS", ")", ";", "//ignore field length normalization", "ft", ".", "setOmitNorms", "(", "true", ")", ";", "// Tip: reuse the Document and Fields for performance...", "// See \"Re-use Document and Field instances\" from", "// http://wiki.apache.org/lucene-java/ImproveIndexingSpeed", "final", "Document", "doc", "=", "new", "Document", "(", ")", ";", "final", "Field", "v", "=", "new", "Field", "(", "Fields", ".", "VENDOR", ",", "Fields", ".", "VENDOR", ",", "ft", ")", ";", "final", "Field", "p", "=", "new", "Field", "(", "Fields", ".", "PRODUCT", ",", "Fields", ".", "PRODUCT", ",", "ft", ")", ";", "doc", ".", "add", "(", "v", ")", ";", "doc", ".", "add", "(", "p", ")", ";", "final", "Set", "<", "Pair", "<", "String", ",", "String", ">", ">", "data", "=", "cve", ".", "getVendorProductList", "(", ")", ";", "for", "(", "Pair", "<", "String", ",", "String", ">", "pair", ":", "data", ")", "{", "if", "(", "pair", ".", "getLeft", "(", ")", "!=", "null", "&&", "pair", ".", "getRight", "(", ")", "!=", "null", ")", "{", "v", ".", "setStringValue", "(", "pair", ".", "getLeft", "(", ")", ")", ";", "p", ".", "setStringValue", "(", "pair", ".", "getRight", "(", ")", ")", ";", "indexWriter", ".", "addDocument", "(", "doc", ")", ";", "resetAnalyzers", "(", ")", ";", "}", "}", "indexWriter", ".", "commit", "(", ")", ";", "}", "catch", "(", "DatabaseException", "ex", ")", "{", "LOGGER", ".", "debug", "(", "\"\"", ",", "ex", ")", ";", "throw", "new", "IndexException", "(", "\"Error reading CPE data\"", ",", "ex", ")", ";", "}", "catch", "(", "IOException", "ex", ")", "{", "throw", "new", "IndexException", "(", "\"Unable to close an in-memory index\"", ",", "ex", ")", ";", "}", "}" ]

[ "Builds", "the", "CPE", "Lucene", "Index", "based", "off", "of", "the", "data", "within", "the", "CveDB", "." ]

[ "public", "static", "<", "T", "extends", "UnixTime", ">", "StartOfDay", "definedBy", "(", "ChronoFunction", "<", "CalendarDate", ",", "Optional", "<", "T", ">", ">", "event", ")", "{", "return", "new", "FunctionalStartOfDay", "<>", "(", "event", ")", ";", "}" ]

[ "/", "*", "[", "deutsch", "]", "<p", ">", "Liefert", "den", "Start", "eines", "Kalendertags", "wie", "von", "der", "angegebenen", "Datumsfunktion", "bestimmt", ".", "<", "/", "p", ">" ]