Datasets:

---

stojchet

/

base_prediction_dataset

like 0

[ "public", "AnnotatedTextBuilder", "addGlobalMetaData", "(", "String", "key", ",", "String", "value", ")", "{", "customMetaData", ".", "put", "(", "key", ",", "value", ")", ";", "return", "this", ";", "}" ]

[ "Add", "any", "global", "meta", "data", "about", "the", "document", "to", "be", "checked", ".", "Some", "rules", "may", "use", "this", "information", ".", "Unless", "you", "re", "using", "your", "own", "rules", "for", "which", "you", "know", "useful", "keys", "you", "probably", "want", "to", "use", "{" ]

[ "public", "static", "RelationalBinding", "equalBinding", "(", "final", "String", "property", ",", "final", "Object", "value", ")", "{", "return", "(", "new", "RelationalBinding", "(", "property", ",", "Relation", ".", "EQUAL", ",", "value", ")", ")", ";", "}" ]

[ "Creates", "an", "EQUAL", "binding", "." ]

[ "@", "Override", "protected", "void", "suspendFaxJobImpl", "(", "FaxJob", "faxJob", ")", "{", "//get fax job", "HylaFaxJob", "hylaFaxJob", "=", "(", "HylaFaxJob", ")", "faxJob", ";", "//get client", "HylaFAXClient", "client", "=", "this", ".", "getHylaFAXClient", "(", ")", ";", "try", "{", "this", ".", "suspendFaxJob", "(", "hylaFaxJob", ",", "client", ")", ";", "}", "catch", "(", "FaxException", "exception", ")", "{", "throw", "exception", ";", "}", "catch", "(", "Exception", "exception", ")", "{", "throw", "new", "FaxException", "(", "\"General error.\"", ",", "exception", ")", ";", "}", "}" ]

[ "This", "function", "will", "suspend", "an", "existing", "fax", "job", "." ]

[ "public", "static", "<", "T", ">", "void", "rsort", "(", "List", "<", "T", ">", "a", ",", "Comparator", "<", "?", "super", "T", ">", "comp", ")", "{", "sort", "(", "a", ",", "Collections", ".", "reverseOrder", "(", "comp", ")", ")", ";", "}" ]

[ "Sort", "the", "elements", "in", "the", "specified", "List", "according", "to", "the", "reverse", "ordering", "imposed", "by", "the", "specified", "Comparator", "." ]

[ "private", "TypeSpec", "createFormatter", "(", "DateTimeData", "dateTimeData", ",", "TimeZoneData", "timeZoneData", ",", "String", "className", ")", "{", "LocaleID", "id", "=", "dateTimeData", ".", "id", ";", "MethodSpec", ".", "Builder", "constructor", "=", "MethodSpec", ".", "constructorBuilder", "(", ")", ".", "addModifiers", "(", "PUBLIC", ")", ";", "constructor", ".", "addStatement", "(", "\"this.bundleId = $T.$L\"", ",", "CLDR_LOCALE_IF", ",", "id", ".", "safe", ")", ";", "constructor", ".", "addStatement", "(", "\"this.firstDay = $L\"", ",", "dateTimeData", ".", "firstDay", ")", ";", "constructor", ".", "addStatement", "(", "\"this.minDays = $L\"", ",", "dateTimeData", ".", "minDays", ")", ";", "variantsFieldInit", "(", "constructor", ",", "\"this.eras\"", ",", "dateTimeData", ".", "eras", ")", ";", "variantsFieldInit", "(", "constructor", ",", "\"this.quartersFormat\"", ",", "dateTimeData", ".", "quartersFormat", ")", ";", "variantsFieldInit", "(", "constructor", ",", "\"this.quartersStandalone\"", ",", "dateTimeData", ".", "quartersStandalone", ")", ";", "variantsFieldInit", "(", "constructor", ",", "\"this.monthsFormat\"", ",", "dateTimeData", ".", "monthsFormat", ")", ";", "variantsFieldInit", "(", "constructor", ",", "\"this.monthsStandalone\"", ",", "dateTimeData", ".", "monthsStandalone", ")", ";", "variantsFieldInit", "(", "constructor", ",", "\"this.weekdaysFormat\"", ",", "dateTimeData", ".", "weekdaysFormat", ")", ";", "variantsFieldInit", "(", "constructor", ",", "\"this.weekdaysStandalone\"", ",", "dateTimeData", ".", "weekdaysStandalone", ")", ";", "variantsFieldInit", "(", "constructor", ",", "\"this.dayPeriodsFormat\"", ",", "dateTimeData", ".", "dayPeriodsFormat", ")", ";", "variantsFieldInit", "(", "constructor", ",", "\"this.dayPeriodsStandalone\"", ",", "dateTimeData", ".", "dayPeriodsStandalone", ")", ";", "buildTimeZoneExemplarCities", "(", "constructor", ",", "timeZoneData", ")", ";", "buildTimeZoneNames", "(", "constructor", ",", "timeZoneData", ")", ";", "buildMetaZoneNames", "(", "constructor", ",", "timeZoneData", ")", ";", "TypeSpec", ".", "Builder", "type", "=", "TypeSpec", ".", "classBuilder", "(", "className", ")", ".", "superclass", "(", "CALENDAR_FORMATTER", ")", ".", "addModifiers", "(", "PUBLIC", ")", ".", "addJavadoc", "(", "\"Locale \\\"\"", "+", "dateTimeData", ".", "id", "+", "\"\\\"\\n\"", "+", "\"See http://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table\\n\"", ")", ".", "addMethod", "(", "constructor", ".", "build", "(", ")", ")", ";", "MethodSpec", "dateMethod", "=", "buildTypedPatternMethod", "(", "\"formatDate\"", ",", "CALENDAR_FORMAT", ",", "dateTimeData", ".", "dateFormats", ")", ";", "MethodSpec", "timeMethod", "=", "buildTypedPatternMethod", "(", "\"formatTime\"", ",", "CALENDAR_FORMAT", ",", "dateTimeData", ".", "timeFormats", ")", ";", "MethodSpec", "wrapperMethod", "=", "buildWrapperMethod", "(", "dateTimeData", ".", "dateTimeFormats", ")", ";", "MethodSpec", "skeletonMethod", "=", "buildSkeletonFormatter", "(", "dateTimeData", ".", "dateTimeSkeletons", ")", ";", "MethodSpec", "intervalMethod", "=", "buildIntervalMethod", "(", "dateTimeData", ".", "intervalFormats", ",", "dateTimeData", ".", "intervalFallbackFormat", ")", ";", "MethodSpec", "gmtMethod", "=", "buildWrapTimeZoneGMTMethod", "(", "timeZoneData", ")", ";", "MethodSpec", "regionFormatMethod", "=", "buildWrapTimeZoneRegionMethod", "(", "timeZoneData", ")", ";", "return", "type", ".", "addMethod", "(", "dateMethod", ")", ".", "addMethod", "(", "timeMethod", ")", ".", "addMethod", "(", "wrapperMethod", ")", ".", "addMethod", "(", "skeletonMethod", ")", ".", "addMethod", "(", "intervalMethod", ")", ".", "addMethod", "(", "gmtMethod", ")", ".", "addMethod", "(", "regionFormatMethod", ")", ".", "build", "(", ")", ";", "}" ]

[ "Create", "a", "Java", "class", "that", "captures", "all", "data", "formats", "for", "a", "given", "locale", "." ]

[ "private", "Matrix", "calculateEdgeSimMatrix", "(", "final", "List", "<", "Edge", ">", "edgeList", ",", "final", "SparseMatrix", "sm", ")", "{", "final", "int", "numEdges", "=", "edgeList", ".", "size", "(", ")", ";", "final", "Matrix", "edgeSimMatrix", "=", "new", "SparseSymmetricMatrix", "(", "new", "SparseHashMatrix", "(", "numEdges", ",", "numEdges", ")", ")", ";", "Object", "key", "=", "workQueue", ".", "registerTaskGroup", "(", "numEdges", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "numEdges", ";", "++", "i", ")", "{", "final", "int", "row", "=", "i", ";", "workQueue", ".", "add", "(", "key", ",", "new", "Runnable", "(", ")", "{", "public", "void", "run", "(", ")", "{", "for", "(", "int", "j", "=", "row", ";", "j", "<", "numEdges", ";", "++", "j", ")", "{", "Edge", "e1", "=", "edgeList", ".", "get", "(", "row", ")", ";", "Edge", "e2", "=", "edgeList", ".", "get", "(", "j", ")", ";", "double", "sim", "=", "getEdgeSimilarity", "(", "sm", ",", "e1", ",", "e2", ")", ";", "if", "(", "sim", ">", "0", ")", "{", "// The symmetric matrix handles the (j,i) case", "edgeSimMatrix", ".", "set", "(", "row", ",", "j", ",", "sim", ")", ";", "}", "}", "}", "}", ")", ";", "}", "workQueue", ".", "await", "(", "key", ")", ";", "return", "edgeSimMatrix", ";", "}" ]

[ "Calculates", "the", "similarity", "matrix", "for", "the", "edges", ".", "The", "similarity", "matrix", "is", "symmetric", "." ]

[ "private", "String", "getFieldAccessorName", "(", "TypeToken", "<", "?", ">", "recordType", ",", "String", "fieldName", ")", "{", "return", "String", ".", "format", "(", "\"%s$%s\"", ",", "normalizeTypeName", "(", "recordType", ")", ",", "fieldName", ")", ";", "}" ]

[ "Generates", "the", "name", "of", "the", "class", "field", "for", "storing", "{" ]

[ "public", "void", "asyncPost", "(", "final", "String", "url", ",", "final", "String", "mediaType", ",", "final", "Supplier", "<", "String", ">", "supplier", ",", "final", "Callback", "callback", ")", "{", "requireNonNull", "(", "supplier", ",", "\"A valid supplier expected\"", ")", ";", "asyncPostBytes", "(", "url", ",", "mediaType", ",", "(", ")", "->", "ofNullable", "(", "supplier", ".", "get", "(", ")", ")", ".", "orElse", "(", "\"\"", ")", ".", "getBytes", "(", ")", ",", "callback", ")", ";", "}" ]

[ "Posts", "data", "to", "a", "server", "via", "a", "HTTP", "POST", "request", "." ]

[ "public", "Jar", "addEntries", "(", "Path", "path", ",", "ZipInputStream", "zip", ")", "throws", "IOException", "{", "return", "addEntries", "(", "path", ",", "zip", ",", "null", ")", ";", "}" ]

[ "Adds", "the", "contents", "of", "the", "zip", "/", "JAR", "contained", "in", "the", "given", "byte", "array", "to", "this", "JAR", "." ]

[ "public", "Cell", "getCell", "(", "int", "column", ",", "int", "row", ")", "{", "return", "this", ".", "workbook", ".", "getSheetAt", "(", "sheetIndex", ")", ".", "getRow", "(", "row", ")", ".", "getCell", "(", "column", ")", ";", "}" ]

[ "获取指定sheet的指定行列单元格" ]

[ "public", "boolean", "hasNextBigInteger", "(", "int", "radix", ")", "{", "setRadix", "(", "radix", ")", ";", "boolean", "result", "=", "hasNext", "(", "integerPattern", "(", ")", ")", ";", "if", "(", "result", ")", "{", "// Cache it", "try", "{", "String", "s", "=", "(", "matcher", ".", "group", "(", "SIMPLE_GROUP_INDEX", ")", "==", "null", ")", "?", "processIntegerToken", "(", "hasNextResult", ")", ":", "hasNextResult", ";", "typeCache", "=", "new", "BigInteger", "(", "s", ",", "radix", ")", ";", "}", "catch", "(", "NumberFormatException", "nfe", ")", "{", "result", "=", "false", ";", "}", "}", "return", "result", ";", "}" ]

[ "Returns", "true", "if", "the", "next", "token", "in", "this", "scanner", "s", "input", "can", "be", "interpreted", "as", "a", "<code", ">", "BigInteger<", "/", "code", ">", "in", "the", "specified", "radix", "using", "the", "{", "@link", "#nextBigInteger", "}", "method", ".", "The", "scanner", "does", "not", "advance", "past", "any", "input", "." ]

[ "public", "Node", "getNode", "(", "String", "id", ")", "throws", "NoResponseException", ",", "XMPPErrorException", ",", "NotConnectedException", ",", "InterruptedException", ",", "NotAPubSubNodeException", "{", "Node", "node", "=", "nodeMap", ".", "get", "(", "id", ")", ";", "if", "(", "node", "==", "null", ")", "{", "DiscoverInfo", "info", "=", "new", "DiscoverInfo", "(", ")", ";", "info", ".", "setTo", "(", "pubSubService", ")", ";", "info", ".", "setNode", "(", "id", ")", ";", "DiscoverInfo", "infoReply", "=", "connection", "(", ")", ".", "createStanzaCollectorAndSend", "(", "info", ")", ".", "nextResultOrThrow", "(", ")", ";", "if", "(", "infoReply", ".", "hasIdentity", "(", "PubSub", ".", "ELEMENT", ",", "\"leaf\"", ")", ")", "{", "node", "=", "new", "LeafNode", "(", "this", ",", "id", ")", ";", "}", "else", "if", "(", "infoReply", ".", "hasIdentity", "(", "PubSub", ".", "ELEMENT", ",", "\"collection\"", ")", ")", "{", "node", "=", "new", "CollectionNode", "(", "this", ",", "id", ")", ";", "}", "else", "{", "throw", "new", "PubSubException", ".", "NotAPubSubNodeException", "(", "id", ",", "infoReply", ")", ";", "}", "nodeMap", ".", "put", "(", "id", ",", "node", ")", ";", "}", "return", "node", ";", "}" ]

[ "Retrieves", "the", "requested", "node", "if", "it", "exists", ".", "It", "will", "throw", "an", "exception", "if", "it", "does", "not", "." ]

[ "public", "static", "String", "getSDbl", "(", "double", "Value", ",", "int", "DecPrec", ")", "{", "//", "String", "Result", "=", "\"\"", ";", "//", "if", "(", "Double", ".", "isNaN", "(", "Value", ")", ")", "return", "\"NaN\"", ";", "//", "if", "(", "DecPrec", "<", "0", ")", "DecPrec", "=", "0", ";", "//", "String", "DFS", "=", "\"###,###,##0\"", ";", "//", "if", "(", "DecPrec", ">", "0", ")", "{", "int", "idx", "=", "0", ";", "DFS", "+=", "\".\"", ";", "while", "(", "idx", "<", "DecPrec", ")", "{", "DFS", "=", "DFS", "+", "\"0\"", ";", "idx", "++", ";", "if", "(", "idx", ">", "100", ")", "break", ";", "}", "}", "//", "//\t\tLocale locale = new Locale(\"en\", \"UK\");", "//", "DecimalFormatSymbols", "DcmFrmSmb", "=", "new", "DecimalFormatSymbols", "(", "Locale", ".", "getDefault", "(", ")", ")", ";", "DcmFrmSmb", ".", "setDecimalSeparator", "(", "'", "'", ")", ";", "DcmFrmSmb", ".", "setGroupingSeparator", "(", "'", "'", ")", ";", "//", "DecimalFormat", "DcmFrm", ";", "//", "DcmFrm", "=", "new", "DecimalFormat", "(", "DFS", ",", "DcmFrmSmb", ")", ";", "//", "//\tDcmFrm.setGroupingSize( 3 );", "//", "Result", "=", "DcmFrm", ".", "format", "(", "Value", ")", ";", "//", "return", "Result", ";", "}" ]

[ "<b", ">", "getSDbl<", "/", "b", ">", "<br", ">", "public", "static", "String", "getSDbl", "(", "double", "Value", "int", "DecPrec", ")", "<br", ">", "Returns", "double", "converted", "to", "string", ".", "<br", ">", "If", "Value", "is", "Double", ".", "NaN", "returns", "NaN", ".", "<br", ">", "If", "DecPrec", "is", "<", "0", "is", "DecPrec", "set", "0", ".", "<br", ">" ]

[ "public", "void", "ip_arp_ipBlocked_unblock_POST", "(", "String", "ip", ",", "String", "ipBlocked", ")", "throws", "IOException", "{", "String", "qPath", "=", "\"/ip/{ip}/arp/{ipBlocked}/unblock\"", ";", "StringBuilder", "sb", "=", "path", "(", "qPath", ",", "ip", ",", "ipBlocked", ")", ";", "exec", "(", "qPath", ",", "\"POST\"", ",", "sb", ".", "toString", "(", ")", ",", "null", ")", ";", "}" ]

[ "Unblock", "this", "IP" ]

[ "private", "final", "int", "load_digits", "(", "StringBuilder", "sb", ",", "int", "c", ")", "throws", "IOException", "{", "if", "(", "!", "IonTokenConstsX", ".", "isDigit", "(", "c", ")", ")", "{", "return", "c", ";", "}", "sb", ".", "append", "(", "(", "char", ")", "c", ")", ";", "return", "readNumeric", "(", "sb", ",", "Radix", ".", "DECIMAL", ",", "NumericState", ".", "DIGIT", ")", ";", "}" ]

[ "Accumulates", "digits", "into", "the", "buffer", "starting", "with", "the", "given", "character", "." ]

[ "public", "Observable", "<", "Tag", ">", "getTagAsync", "(", "UUID", "projectId", ",", "UUID", "tagId", ",", "GetTagOptionalParameter", "getTagOptionalParameter", ")", "{", "return", "getTagWithServiceResponseAsync", "(", "projectId", ",", "tagId", ",", "getTagOptionalParameter", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "Tag", ">", ",", "Tag", ">", "(", ")", "{", "@", "Override", "public", "Tag", "call", "(", "ServiceResponse", "<", "Tag", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Get", "information", "about", "a", "specific", "tag", "." ]

[ "public", "RulesEnvelope", "getUserRules", "(", "String", "userId", ",", "Boolean", "excludeDisabled", ",", "Integer", "count", ",", "Integer", "offset", ",", "String", "owner", ")", "throws", "ApiException", "{", "ApiResponse", "<", "RulesEnvelope", ">", "resp", "=", "getUserRulesWithHttpInfo", "(", "userId", ",", "excludeDisabled", ",", "count", ",", "offset", ",", "owner", ")", ";", "return", "resp", ".", "getData", "(", ")", ";", "}" ]

[ "Get", "User", "Rules", "Retrieve", "User&#39", ";", "s", "Rules" ]

[ "public", "void", "addProperty", "(", "final", "String", "propertyName", ",", "final", "Collection", "<", "String", ">", "values", ")", "{", "Preconditions", ".", "checkNotNull", "(", "values", ")", ";", "Preconditions", ".", "checkNotNull", "(", "propertyName", ")", ";", "List", "<", "String", ">", "list", "=", "properties", ".", "get", "(", "propertyName", ")", ";", "if", "(", "list", "==", "null", ")", "{", "properties", ".", "put", "(", "propertyName", ",", "new", "ArrayList", "<>", "(", "values", ")", ")", ";", "}", "else", "{", "list", ".", "addAll", "(", "values", ")", ";", "}", "}" ]

[ "Add", "a", "list", "of", "value", "to", "a", "property", "on", "this", "bean", "." ]

[ "public", "static", "AFPChain", "postProcessAlignment", "(", "AFPChain", "afpChain", ",", "Atom", "[", "]", "ca1", ",", "Atom", "[", "]", "ca2m", ",", "CECalculator", "calculator", ")", "throws", "StructureException", "{", "return", "postProcessAlignment", "(", "afpChain", ",", "ca1", ",", "ca2m", ",", "calculator", ",", "null", ")", ";", "}" ]

[ "Circular", "permutation", "specific", "code", "to", "be", "run", "after", "the", "standard", "CE", "alignment" ]

[ "public", "MethodMember", "getCurrentMethod", "(", "String", "name", ",", "String", "descriptor", ")", "{", "if", "(", "liveVersion", "==", "null", ")", "{", "return", "getMethod", "(", "name", ",", "descriptor", ")", ";", "}", "else", "{", "return", "liveVersion", ".", "getReloadableMethod", "(", "name", ",", "descriptor", ")", ";", "}", "}" ]

[ "Gets", "the", "method", "corresponding", "to", "given", "name", "and", "descriptor", "taking", "into", "consideration", "changes", "that", "have", "happened", "by", "reloading", "." ]

[ "public", "void", "downgradeEdgeToInode", "(", "Inode", "inode", ",", "LockMode", "mode", ")", "{", "Preconditions", ".", "checkState", "(", "!", "endsInInode", "(", ")", ")", ";", "Preconditions", ".", "checkState", "(", "!", "mEntries", ".", "isEmpty", "(", ")", ")", ";", "Preconditions", ".", "checkState", "(", "mLockMode", "==", "LockMode", ".", "WRITE", ")", ";", "EdgeEntry", "last", "=", "(", "EdgeEntry", ")", "mEntries", ".", "get", "(", "mEntries", ".", "size", "(", ")", "-", "1", ")", ";", "LockResource", "inodeLock", "=", "mInodeLockManager", ".", "lockInode", "(", "inode", ",", "mode", ")", ";", "LockResource", "edgeLock", "=", "mInodeLockManager", ".", "lockEdge", "(", "last", ".", "mEdge", ",", "LockMode", ".", "READ", ")", ";", "last", ".", "getLock", "(", ")", ".", "close", "(", ")", ";", "mEntries", ".", "set", "(", "mEntries", ".", "size", "(", ")", "-", "1", ",", "new", "EdgeEntry", "(", "edgeLock", ",", "last", ".", "getEdge", "(", ")", ")", ")", ";", "mEntries", ".", "add", "(", "new", "InodeEntry", "(", "inodeLock", ",", "inode", ")", ")", ";", "mLockedInodes", ".", "add", "(", "inode", ")", ";", "mLockMode", "=", "mode", ";", "}" ]

[ "Downgrades", "from", "edge", "write", "-", "locking", "to", "inode", "write", "-", "locking", ".", "This", "reduces", "the", "scope", "of", "the", "write", "lock", "by", "pushing", "it", "forward", "one", "entry", "." ]

[ "private", "static", "ParserInfo", "createParser", "(", "LexiconInductionCcgParserFactory", "factory", ",", "SufficientStatistics", "currentParameters", ",", "Collection", "<", "LexiconEntry", ">", "currentLexicon", ")", "{", "ParametricCcgParser", "family", "=", "factory", ".", "getParametricCcgParser", "(", "currentLexicon", ")", ";", "SufficientStatistics", "newParameters", "=", "family", ".", "getNewSufficientStatistics", "(", ")", ";", "if", "(", "currentParameters", "!=", "null", ")", "{", "newParameters", ".", "transferParameters", "(", "currentParameters", ")", ";", "}", "return", "new", "ParserInfo", "(", "currentLexicon", ",", "family", ",", "newParameters", ",", "family", ".", "getModelFromParameters", "(", "newParameters", ")", ")", ";", "}" ]

[ "Creates", "a", "CCG", "parser", "given", "parameters", "and", "a", "lexicon", "." ]

[ "public", "MatchState", "createState", "(", "Synthesizer", "synthesizer", ",", "AnalyzedTokenReadings", "[", "]", "tokens", ",", "int", "index", ",", "int", "next", ")", "{", "MatchState", "state", "=", "new", "MatchState", "(", "this", ",", "synthesizer", ")", ";", "state", ".", "setToken", "(", "tokens", ",", "index", ",", "next", ")", ";", "return", "state", ";", "}" ]

[ "Creates", "a", "state", "used", "for", "actually", "matching", "a", "token", "." ]

[ "protected", "ClassNode", "inferReturnTypeGenerics", "(", "ClassNode", "receiver", ",", "MethodNode", "method", ",", "Expression", "arguments", ")", "{", "return", "inferReturnTypeGenerics", "(", "receiver", ",", "method", ",", "arguments", ",", "null", ")", ";", "}" ]

[ "If", "a", "method", "call", "returns", "a", "parameterized", "type", "then", "we", "can", "perform", "additional", "inference", "on", "the", "return", "type", "so", "that", "the", "type", "gets", "actual", "type", "parameters", ".", "For", "example", "the", "method", "Arrays", ".", "asList", "(", "T", "...", ")", "is", "generified", "with", "type", "T", "which", "can", "be", "deduced", "from", "actual", "type", "arguments", "." ]

[ "public", "DrawerItem", "setTextSecondary", "(", "String", "textSecondary", ",", "int", "textMode", ")", "{", "mTextSecondary", "=", "textSecondary", ";", "setTextMode", "(", "textMode", ")", ";", "notifyDataChanged", "(", ")", ";", "return", "this", ";", "}" ]

[ "Sets", "a", "secondary", "text", "with", "a", "given", "text", "mode", "to", "the", "drawer", "item" ]

[ "public", "Path", "getPath", "(", "Sprite", "sprite", ",", "int", "x", ",", "int", "y", ",", "boolean", "loose", ")", "{", "// sanity check", "if", "(", "sprite", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Can't get path for null sprite [x=\"", "+", "x", "+", "\", y=\"", "+", "y", "+", "\".\"", ")", ";", "}", "// get the destination tile coordinates", "Point", "src", "=", "MisoUtil", ".", "screenToTile", "(", "_metrics", ",", "sprite", ".", "getX", "(", ")", ",", "sprite", ".", "getY", "(", ")", ",", "new", "Point", "(", ")", ")", ";", "Point", "dest", "=", "MisoUtil", ".", "screenToTile", "(", "_metrics", ",", "x", ",", "y", ",", "new", "Point", "(", ")", ")", ";", "// compute our longest path from the screen size", "int", "longestPath", "=", "3", "*", "(", "getWidth", "(", ")", "/", "_metrics", ".", "tilewid", ")", ";", "// get a reasonable tile path through the scene", "long", "start", "=", "System", ".", "currentTimeMillis", "(", ")", ";", "List", "<", "Point", ">", "points", "=", "AStarPathUtil", ".", "getPath", "(", "this", ",", "sprite", ",", "longestPath", ",", "src", ".", "x", ",", "src", ".", "y", ",", "dest", ".", "x", ",", "dest", ".", "y", ",", "loose", ")", ";", "long", "duration", "=", "System", ".", "currentTimeMillis", "(", ")", "-", "start", ";", "// sanity check the number of nodes searched so that we can keep an eye out for bogosity", "if", "(", "duration", ">", "500L", ")", "{", "int", "considered", "=", "AStarPathUtil", ".", "getConsidered", "(", ")", ";", "log", ".", "warning", "(", "\"Considered \"", "+", "considered", "+", "\" nodes for path from \"", "+", "StringUtil", ".", "toString", "(", "src", ")", "+", "\" to \"", "+", "StringUtil", ".", "toString", "(", "dest", ")", "+", "\" [duration=\"", "+", "duration", "+", "\"].\"", ")", ";", "}", "// construct a path object to guide the sprite on its merry way", "return", "(", "points", "==", "null", ")", "?", "null", ":", "new", "TilePath", "(", "_metrics", ",", "sprite", ",", "points", ",", "x", ",", "y", ")", ";", "}" ]

[ "Computes", "a", "path", "for", "the", "specified", "sprite", "to", "the", "specified", "tile", "coordinates", "." ]

[ "public", "static", "boolean", "hasOneParentPerToken", "(", "int", "n", ",", "VarConfig", "vc", ")", "{", "int", "[", "]", "parents", "=", "new", "int", "[", "n", "]", ";", "Arrays", ".", "fill", "(", "parents", ",", "-", "2", ")", ";", "for", "(", "Var", "v", ":", "vc", ".", "getVars", "(", ")", ")", "{", "if", "(", "v", "instanceof", "LinkVar", ")", "{", "LinkVar", "link", "=", "(", "LinkVar", ")", "v", ";", "if", "(", "vc", ".", "getState", "(", "v", ")", "==", "LinkVar", ".", "TRUE", ")", "{", "if", "(", "parents", "[", "link", ".", "getChild", "(", ")", "]", "!=", "-", "2", ")", "{", "// Multiple parents defined for the same child.", "return", "false", ";", "}", "parents", "[", "link", ".", "getChild", "(", ")", "]", "=", "link", ".", "getParent", "(", ")", ";", "}", "}", "}", "return", "!", "ArrayUtils", ".", "contains", "(", "parents", ",", "-", "2", ")", ";", "}" ]

[ "Returns", "whether", "this", "variable", "assignment", "specifies", "one", "parent", "per", "token", "." ]

[ "private", "void", "sendAck", "(", "String", "index", ",", "String", "message", ",", "GuacamoleStatus", "status", ")", "{", "// Error \"ack\" instructions implicitly close the stream", "if", "(", "status", "!=", "GuacamoleStatus", ".", "SUCCESS", ")", "closeInterceptedStream", "(", "index", ")", ";", "sendInstruction", "(", "new", "GuacamoleInstruction", "(", "\"ack\"", ",", "index", ",", "message", ",", "Integer", ".", "toString", "(", "status", ".", "getGuacamoleStatusCode", "(", ")", ")", ")", ")", ";", "}" ]

[ "Injects", "an", "ack", "instruction", "into", "the", "outbound", "Guacamole", "protocol", "stream", "as", "if", "sent", "by", "the", "connected", "client", ".", "ack", "instructions", "are", "used", "to", "acknowledge", "the", "receipt", "of", "a", "stream", "and", "its", "subsequent", "blobs", "and", "are", "the", "only", "means", "of", "communicating", "success", "/", "failure", "status", "." ]

[ "public", "static", "String", "calcSaturatedMoisture", "(", "String", "slsnd", ",", "String", "slcly", ",", "String", "omPct", ")", "{", "String", "mt33", "=", "calcMoisture33Kpa", "(", "slsnd", ",", "slcly", ",", "omPct", ")", ";", "String", "mtSAT33", "=", "calcMoistureSAT33Kpa", "(", "slsnd", ",", "slcly", ",", "omPct", ")", ";", "String", "ret", "=", "sum", "(", "mt33", ",", "mtSAT33", ",", "product", "(", "slsnd", ",", "\"-0.097\"", ")", ",", "\"4.3\"", ")", ";", "LOG", ".", "debug", "(", "\"Calculate result for Saturated moisture (0 kPa), normal density, %v is {}\"", ",", "ret", ")", ";", "return", "ret", ";", "}" ]

[ "Equation", "5", "for", "calculating", "Saturated", "moisture", "(", "0", "kPa", ")", "normal", "density", "%v" ]

[ "public", "AgreementTermsInner", "getAgreement", "(", "String", "publisherId", ",", "String", "offerId", ",", "String", "planId", ")", "{", "return", "getAgreementWithServiceResponseAsync", "(", "publisherId", ",", "offerId", ",", "planId", ")", ".", "toBlocking", "(", ")", ".", "single", "(", ")", ".", "body", "(", ")", ";", "}" ]

[ "Get", "marketplace", "agreement", "." ]

[ "public", "static", "boolean", "matchesQName", "(", "QName", "regQName", ",", "QName", "targetQName", ",", "boolean", "ignorePrefix", ")", "{", "if", "(", "regQName", "==", "null", "||", "targetQName", "==", "null", ")", "{", "return", "false", ";", "}", "if", "(", "\"*\"", ".", "equals", "(", "getQNameString", "(", "regQName", ")", ")", ")", "{", "return", "true", ";", "}", "// if the name space or the prefix is not equal, just return false;", "if", "(", "!", "(", "regQName", ".", "getNamespaceURI", "(", ")", ".", "equals", "(", "targetQName", ".", "getNamespaceURI", "(", ")", ")", ")", "||", "!", "(", "ignorePrefix", "||", "regQName", ".", "getPrefix", "(", ")", ".", "equals", "(", "targetQName", ".", "getPrefix", "(", ")", ")", ")", ")", "{", "return", "false", ";", "}", "if", "(", "regQName", ".", "getLocalPart", "(", ")", ".", "contains", "(", "\"*\"", ")", ")", "{", "return", "Pattern", ".", "matches", "(", "mapPattern", "(", "regQName", ".", "getLocalPart", "(", ")", ")", ",", "targetQName", ".", "getLocalPart", "(", ")", ")", ";", "}", "else", "if", "(", "regQName", ".", "getLocalPart", "(", ")", ".", "equals", "(", "targetQName", ".", "getLocalPart", "(", ")", ")", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Check", "whether", "the", "regQName", "matches", "the", "targetQName" ]

[ "public", "ConnectionSharedKeyInner", "setSharedKey", "(", "String", "resourceGroupName", ",", "String", "virtualNetworkGatewayConnectionName", ",", "ConnectionSharedKeyInner", "parameters", ")", "{", "return", "setSharedKeyWithServiceResponseAsync", "(", "resourceGroupName", ",", "virtualNetworkGatewayConnectionName", ",", "parameters", ")", ".", "toBlocking", "(", ")", ".", "last", "(", ")", ".", "body", "(", ")", ";", "}" ]

[ "The", "Put", "VirtualNetworkGatewayConnectionSharedKey", "operation", "sets", "the", "virtual", "network", "gateway", "connection", "shared", "key", "for", "passed", "virtual", "network", "gateway", "connection", "in", "the", "specified", "resource", "group", "through", "Network", "resource", "provider", "." ]

[ "public", "static", "Date", "parseDate", "(", "final", "String", "date", ",", "final", "List", "<", "String", ">", "patterns", ")", "{", "for", "(", "final", "String", "pattern", ":", "patterns", ")", "{", "final", "SimpleDateFormat", "formatter", "=", "new", "SimpleDateFormat", "(", "pattern", ")", ";", "try", "{", "return", "formatter", ".", "parse", "(", "date", ")", ";", "}", "catch", "(", "final", "ParseException", "e", ")", "{", "// Do nothing...", "}", "}", "return", "null", ";", "}" ]

[ "Tries", "to", "convert", "the", "given", "String", "to", "a", "Date", "." ]

[ "public", "static", "Request", "create", "(", "HttpMethod", "httpMethod", ",", "String", "url", ",", "Map", "<", "String", ",", "Collection", "<", "String", ">", ">", "headers", ",", "Body", "body", ")", "{", "return", "new", "Request", "(", "httpMethod", ",", "url", ",", "headers", ",", "body", ")", ";", "}" ]

[ "Builds", "a", "Request", ".", "All", "parameters", "must", "be", "effectively", "immutable", "via", "safe", "copies", "." ]

[ "@", "Override", "public", "boolean", "doBuild", "(", "TopologyBuilder", "bldr", ",", "Set", "<", "String", ">", "stageNames", ")", "{", "// Create and set bolt", "BoltDeclarer", "declarer", ";", "if", "(", "operator", "instanceof", "IStreamletBasicOperator", ")", "{", "setDefaultNameIfNone", "(", "StreamletNamePrefix", ".", "CUSTOM", ",", "stageNames", ")", ";", "IStreamletBasicOperator", "<", "R", ",", "T", ">", "op", "=", "(", "IStreamletBasicOperator", "<", "R", ",", "T", ">", ")", "operator", ";", "bldr", ".", "setBolt", "(", "getName", "(", ")", ",", "op", ",", "getNumPartitions", "(", ")", ")", ".", "grouping", "(", "parent", ".", "getName", "(", ")", ",", "parent", ".", "getStreamId", "(", ")", ",", "grouper", ")", ";", "}", "else", "if", "(", "operator", "instanceof", "IStreamletRichOperator", ")", "{", "setDefaultNameIfNone", "(", "StreamletNamePrefix", ".", "CUSTOM_BASIC", ",", "stageNames", ")", ";", "IStreamletRichOperator", "<", "R", ",", "T", ">", "op", "=", "(", "IStreamletRichOperator", "<", "R", ",", "T", ">", ")", "operator", ";", "bldr", ".", "setBolt", "(", "getName", "(", ")", ",", "op", ",", "getNumPartitions", "(", ")", ")", ".", "grouping", "(", "parent", ".", "getName", "(", ")", ",", "parent", ".", "getStreamId", "(", ")", ",", "grouper", ")", ";", "}", "else", "if", "(", "operator", "instanceof", "IStreamletWindowOperator", ")", "{", "setDefaultNameIfNone", "(", "StreamletNamePrefix", ".", "CUSTOM_WINDOW", ",", "stageNames", ")", ";", "IStreamletWindowOperator", "<", "R", ",", "T", ">", "op", "=", "(", "IStreamletWindowOperator", "<", "R", ",", "T", ">", ")", "operator", ";", "bldr", ".", "setBolt", "(", "getName", "(", ")", ",", "op", ",", "getNumPartitions", "(", ")", ")", ".", "grouping", "(", "parent", ".", "getName", "(", ")", ",", "parent", ".", "getStreamId", "(", ")", ",", "grouper", ")", ";", "}", "else", "{", "throw", "new", "RuntimeException", "(", "\"Unhandled operator class is found!\"", ")", ";", "}", "return", "true", ";", "}" ]

[ "Connect", "this", "streamlet", "to", "TopologyBuilder", "." ]

[ "public", "FessMessages", "addSuccessUploadDesignFile", "(", "String", "property", ",", "String", "arg0", ")", "{", "assertPropertyNotNull", "(", "property", ")", ";", "add", "(", "property", ",", "new", "UserMessage", "(", "SUCCESS_upload_design_file", ",", "arg0", ")", ")", ";", "return", "this", ";", "}" ]

[ "Add", "the", "created", "action", "message", "for", "the", "key", "success", ".", "upload_design_file", "with", "parameters", ".", "<pre", ">", "message", ":", "Uploaded", "{", "0", "}", ".", "<", "/", "pre", ">" ]

[ "@", "Conditioned", "@", "Lorsque", "(", "\"Je ferme la fenêtre actuelle et passe à la fenêtre '(.*)'[\\\\.|\\\\?]\")\r", "", "@", "Then", "(", "\"I close current window and switch to '(.*)' window[\\\\.|\\\\?]\"", ")", "public", "void", "closeWindowAndSwitchTo", "(", "String", "key", ",", "List", "<", "GherkinStepCondition", ">", "conditions", ")", "throws", "TechnicalException", ",", "FailureException", "{", "closeWindowAndSwitchTo", "(", "key", ")", ";", "}" ]

[ "Closes", "window", "and", "switches", "to", "target", "window", "with", "conditions", "." ]

[ "public", "static", "String", "formatDate", "(", "long", "date", ",", "String", "format", ",", "String", "timeZone", ")", "{", "return", "formatDateBase", "(", "date", ",", "format", ",", "timeZone", ")", ";", "}" ]

[ "Gets", "a", "date", "with", "a", "desired", "format", "as", "a", "String" ]

[ "private", "static", "void", "addFile", "(", "final", "File", "file", ",", "final", "File", "dirToZip", ",", "final", "ZipOutputStream", "zos", ")", "throws", "IOException", "{", "final", "String", "absolutePath", "=", "file", ".", "getAbsolutePath", "(", ")", ";", "final", "int", "index", "=", "absolutePath", ".", "indexOf", "(", "dirToZip", ".", "getName", "(", ")", ")", ";", "final", "String", "zipEntryName", "=", "absolutePath", ".", "substring", "(", "index", ",", "absolutePath", ".", "length", "(", ")", ")", ";", "final", "byte", "[", "]", "b", "=", "new", "byte", "[", "(", "int", ")", "file", ".", "length", "(", ")", "]", ";", "final", "ZipEntry", "cpZipEntry", "=", "new", "ZipEntry", "(", "zipEntryName", ")", ";", "zos", ".", "putNextEntry", "(", "cpZipEntry", ")", ";", "zos", ".", "write", "(", "b", ",", "0", ",", "(", "int", ")", "file", ".", "length", "(", ")", ")", ";", "zos", ".", "closeEntry", "(", ")", ";", "}" ]

[ "Adds", "the", "file", "." ]

[ "public", "void", "addIfAbsent", "(", "CharSequence", "variant", ",", "String", "template", ")", "{", "int", "idx", "=", "StandardPlural", ".", "indexFromString", "(", "variant", ")", ";", "if", "(", "templates", "[", "idx", "]", "!=", "null", ")", "{", "return", ";", "}", "templates", "[", "idx", "]", "=", "SimpleFormatter", ".", "compileMinMaxArguments", "(", "template", ",", "0", ",", "1", ")", ";", "}" ]

[ "Adds", "a", "template", "if", "there", "is", "none", "yet", "for", "the", "plural", "form", "." ]

[ "@", "Nullable", "private", "EventExecutorGroup", "createEventExecutorGroup", "(", "int", "size", ")", "{", "if", "(", "size", "<=", "0", ")", "{", "return", "null", ";", "}", "ThreadFactory", "threadFactory", "=", "new", "ThreadFactory", "(", ")", "{", "private", "final", "ThreadGroup", "threadGroup", "=", "new", "ThreadGroup", "(", "serviceName", "+", "\"-executor-thread\"", ")", ";", "private", "final", "AtomicLong", "count", "=", "new", "AtomicLong", "(", "0", ")", ";", "@", "Override", "public", "Thread", "newThread", "(", "Runnable", "r", ")", "{", "Thread", "t", "=", "new", "Thread", "(", "threadGroup", ",", "r", ",", "String", ".", "format", "(", "\"%s-executor-%d\"", ",", "serviceName", ",", "count", ".", "getAndIncrement", "(", ")", ")", ")", ";", "t", ".", "setDaemon", "(", "true", ")", ";", "return", "t", ";", "}", "}", ";", "UnorderedThreadPoolEventExecutor", "executor", "=", "new", "UnorderedThreadPoolEventExecutor", "(", "size", ",", "threadFactory", ",", "rejectedExecutionHandler", ")", ";", "if", "(", "execThreadKeepAliveSecs", ">", "0", ")", "{", "executor", ".", "setKeepAliveTime", "(", "execThreadKeepAliveSecs", ",", "TimeUnit", ".", "SECONDS", ")", ";", "executor", ".", "allowCoreThreadTimeOut", "(", "true", ")", ";", "}", "return", "new", "NonStickyEventExecutorGroup", "(", "executor", ")", ";", "}" ]

[ "Create", "{", "@link", "EventExecutorGroup", "}", "for", "executing", "handle", "methods", "." ]

[ "public", "void", "unregisterListener", "(", "IPluginEventListener", "listener", ")", "{", "if", "(", "pluginEventListeners2", "!=", "null", "&&", "pluginEventListeners2", ".", "contains", "(", "listener", ")", ")", "{", "pluginEventListeners2", ".", "remove", "(", "listener", ")", ";", "listener", ".", "onPluginEvent", "(", "new", "PluginEvent", "(", "this", ",", "PluginAction", ".", "UNSUBSCRIBE", ")", ")", ";", "}", "}" ]

[ "Unregisters", "a", "listener", "for", "the", "IPluginEvent", "callback", "event", "." ]

[ "@", "Override", "public", "void", "removeByC_C", "(", "long", "classNameId", ",", "long", "classPK", ")", "{", "for", "(", "CommerceAddress", "commerceAddress", ":", "findByC_C", "(", "classNameId", ",", "classPK", ",", "QueryUtil", ".", "ALL_POS", ",", "QueryUtil", ".", "ALL_POS", ",", "null", ")", ")", "{", "remove", "(", "commerceAddress", ")", ";", "}", "}" ]

[ "Removes", "all", "the", "commerce", "addresses", "where", "classNameId", "=", "&#63", ";", "and", "classPK", "=", "&#63", ";", "from", "the", "database", "." ]

[ "public", "String", "getDisplayName", "(", "TextStyle", "style", ",", "Locale", "locale", ")", "{", "return", "new", "DateTimeFormatterBuilder", "(", ")", ".", "appendZoneText", "(", "style", ")", ".", "toFormatter", "(", "locale", ")", ".", "format", "(", "toTemporal", "(", ")", ")", ";", "}" ]

[ "Gets", "the", "textual", "representation", "of", "the", "zone", "such", "as", "British", "Time", "or", "+", "02", ":", "00", ".", "<p", ">", "This", "returns", "the", "textual", "name", "used", "to", "identify", "the", "time", "-", "zone", "ID", "suitable", "for", "presentation", "to", "the", "user", ".", "The", "parameters", "control", "the", "style", "of", "the", "returned", "text", "and", "the", "locale", ".", "<p", ">", "If", "no", "textual", "mapping", "is", "found", "then", "the", "{", "@link", "#getId", "()", "full", "ID", "}", "is", "returned", "." ]

[ "@", "Override", "public", "InputStream", "getFileStream", "(", "String", "file", ")", "throws", "FileBasedHelperException", "{", "SftpGetMonitor", "monitor", "=", "new", "SftpGetMonitor", "(", ")", ";", "try", "{", "ChannelSftp", "channel", "=", "getSftpChannel", "(", ")", ";", "return", "new", "SftpFsFileInputStream", "(", "channel", ".", "get", "(", "file", ",", "monitor", ")", ",", "channel", ")", ";", "}", "catch", "(", "SftpException", "e", ")", "{", "throw", "new", "FileBasedHelperException", "(", "\"Cannot download file \"", "+", "file", "+", "\" due to \"", "+", "e", ".", "getMessage", "(", ")", ",", "e", ")", ";", "}", "}" ]

[ "Executes", "a", "get", "SftpCommand", "and", "returns", "an", "input", "stream", "to", "the", "file" ]

[ "private", "void", "parseConfiguration", "(", "CmsObject", "cms", ",", "CmsMessages", "widgetDialog", ")", "{", "String", "configString", "=", "CmsMacroResolver", ".", "resolveMacros", "(", "getConfiguration", "(", ")", ",", "cms", ",", "widgetDialog", ")", ";", "Map", "<", "String", ",", "String", ">", "config", "=", "CmsStringUtil", ".", "splitAsMap", "(", "configString", ",", "\"|\"", ",", "\"=\"", ")", ";", "// get the list of group names to show\r", "String", "groups", "=", "config", ".", "get", "(", "CONFIGURATION_GROUPS", ")", ";", "if", "(", "CmsStringUtil", ".", "isNotEmptyOrWhitespaceOnly", "(", "groups", ")", ")", "{", "m_groupNames", "=", "CmsStringUtil", ".", "splitAsList", "(", "groups", ",", "'", "'", ",", "true", ")", ";", "}", "// get the regular expression to filter the groups\r", "String", "filter", "=", "config", ".", "get", "(", "CONFIGURATION_GROUPFILTER", ")", ";", "if", "(", "CmsStringUtil", ".", "isNotEmptyOrWhitespaceOnly", "(", "filter", ")", ")", "{", "try", "{", "m_groupFilter", "=", "Pattern", ".", "compile", "(", "filter", ")", ";", "}", "catch", "(", "PatternSyntaxException", "e", ")", "{", "// log pattern syntax errors\r", "LOG", ".", "error", "(", "Messages", ".", "get", "(", ")", ".", "getBundle", "(", ")", ".", "key", "(", "Messages", ".", "LOG_ERR_WIDGET_SELECTGROUP_PATTERN_1", ",", "filter", ")", ")", ";", "}", "}", "// get the OU to read the groups from\r", "m_ouFqn", "=", "config", ".", "get", "(", "CONFIGURATION_OUFQN", ")", ";", "if", "(", "CmsStringUtil", ".", "isEmptyOrWhitespaceOnly", "(", "m_ouFqn", ")", ")", "{", "m_ouFqn", "=", "\"\"", ";", "}", "else", "if", "(", "!", "m_ouFqn", ".", "endsWith", "(", "CmsOrganizationalUnit", ".", "SEPARATOR", ")", ")", "{", "m_ouFqn", "+=", "CmsOrganizationalUnit", ".", "SEPARATOR", ";", "}", "// set the flag to include sub OUs\r", "m_includeSubOus", "=", "Boolean", ".", "parseBoolean", "(", "config", ".", "get", "(", "CONFIGURATION_INCLUDESUBOUS", ")", ")", ";", "m_defaultAllAvailable", "=", "Boolean", ".", "parseBoolean", "(", "config", ".", "get", "(", "CONFIGURATION_DEFAULT_ALL", ")", ")", ";", "}" ]

[ "Parses", "the", "widget", "configuration", "string", ".", "<p", ">" ]

[ "public", "ConverterRegistry", "putCustom", "(", "Type", "type", ",", "Class", "<", "?", "extends", "Converter", "<", "?", ">", ">", "converterClass", ")", "{", "return", "putCustom", "(", "type", ",", "ReflectUtil", ".", "newInstance", "(", "converterClass", ")", ")", ";", "}" ]

[ "登记自定义转换器" ]

[ "private", "static", "Ref", "removeCompanionOpt", "(", "List", "<", "Ref", ">", "refs", ",", "Ref", "cmp", ")", "{", "Iterator", "<", "Ref", ">", "iter", ";", "Ref", "ref", ";", "iter", "=", "refs", ".", "iterator", "(", ")", ";", "while", "(", "iter", ".", "hasNext", "(", ")", ")", "{", "ref", "=", "iter", ".", "next", "(", ")", ";", "if", "(", "ref", ".", "module", ".", "equals", "(", "cmp", ".", "module", ")", "&&", "Util", ".", "eq", "(", "ref", ".", "variant", ",", "cmp", ".", "variant", ")", ")", "{", "iter", ".", "remove", "(", ")", ";", "return", "ref", ";", "}", "}", "return", "null", ";", "}" ]

[ "companion", ":", "Ref", "with", "same", "module", "and", "variant", "but", "different", "minimization" ]

[ "public", "void", "setNameSpace", "(", "String", "namespaceURL", ",", "String", "prefix", ")", "throws", "IllegalArgumentException", "{", "Collection", "<", "String", ">", "s", "=", "namespace", ".", "get", "(", "namespaceURL", ")", ";", "if", "(", "s", "==", "null", ")", "{", "s", "=", "new", "HashSet", "<", "String", ">", "(", ")", ";", "}", "s", ".", "add", "(", "prefix", ")", ";", "namespace", ".", "put", "(", "namespaceURL", ",", "s", ")", ";", "this", ".", "prefixes", ".", "put", "(", "prefix", ",", "namespaceURL", ")", ";", "}" ]

[ "<p", ">", "Set", "or", "add", "a", "namespace", "to", "the", "context", "and", "associated", "it", "with", "a", "prefix", ".", "<", "/", "p", ">", "<p", ">", "A", "given", "prefix", "can", "only", "be", "associated", "with", "one", "namespace", "in", "the", "context", ".", "A", "namespace", "can", "have", "multiple", "prefixes", ".", "<", "/", "p", ">", "The", "prefixes", ":", "{", "@code", "xml", "}", "and", "{", "@code", "xmlns", "}", "are", "reserved", "and", "predefined", "in", "any", "context", "." ]

[ "private", "static", "List", "<", "Integer", ">", "exploreExtensions", "(", "ByteBuffer", "input", ",", "List", "<", "Integer", ">", "ciphers", ")", "throws", "SSLException", "{", "int", "length", "=", "getInt16", "(", "input", ")", ";", "// length of extensions", "while", "(", "length", ">", "0", ")", "{", "int", "extType", "=", "getInt16", "(", "input", ")", ";", "// extenson type", "int", "extLen", "=", "getInt16", "(", "input", ")", ";", "// length of extension data", "if", "(", "extType", "==", "16", ")", "{", "// 0x00: ty", "return", "ciphers", ";", "}", "else", "{", "// ignore other extensions", "processByteVector", "(", "input", ",", "extLen", ")", ";", "}", "length", "-=", "extLen", "+", "4", ";", "}", "return", "null", ";", "}" ]

[ "/", "*", "struct", "{", "ExtensionType", "extension_type", ";", "opaque", "extension_data<0", "..", "2^16", "-", "1", ">", ";", "}", "Extension", ";" ]

[ "protected", "static", "Integer", "parseOptionalIntValue", "(", "JSONObject", "json", ",", "String", "key", ")", "{", "try", "{", "return", "Integer", ".", "valueOf", "(", "json", ".", "getInt", "(", "key", ")", ")", ";", "}", "catch", "(", "JSONException", "e", ")", "{", "LOG", ".", "info", "(", "Messages", ".", "get", "(", ")", ".", "getBundle", "(", ")", ".", "key", "(", "Messages", ".", "LOG_OPTIONAL_INTEGER_MISSING_1", ",", "key", ")", ",", "e", ")", ";", "return", "null", ";", "}", "}" ]

[ "Helper", "for", "reading", "an", "optional", "Integer", "value", "-", "returning", "<code", ">", "null<", "/", "code", ">", "if", "parsing", "fails", "." ]

[ "public", "List", "<", "String", ">", "getList", "(", "String", "key", ")", "{", "if", "(", "!", "containsKey", "(", "key", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Missing key \"", "+", "key", "+", "\".\"", ")", ";", "}", "return", "getList", "(", "key", ",", "null", ")", ";", "}" ]

[ "Gets", "the", "string", "list", "value", "<code", ">", "key<", "/", "code", ">", "." ]

[ "public", "void", "setAttenuation", "(", "float", "constant", ",", "float", "linear", ",", "float", "quadratic", ")", "{", "setFloat", "(", "\"attenuation_constant\"", ",", "constant", ")", ";", "setFloat", "(", "\"attenuation_linear\"", ",", "linear", ")", ";", "setFloat", "(", "\"attenuation_quadratic\"", ",", "quadratic", ")", ";", "}" ]

[ "Set", "the", "three", "attenuation", "constants", "to", "control", "how", "light", "falls", "off", "based", "on", "distance", "from", "the", "light", "source", ".", "{" ]

[ "public", "RowMajorMatrixIterator", "nonZeroRowMajorIterator", "(", ")", "{", "return", "new", "RowMajorMatrixIterator", "(", "rows", ",", "columns", ")", "{", "private", "long", "limit", "=", "(", "long", ")", "rows", "*", "columns", ";", "private", "long", "i", "=", "-", "1", ";", "@", "Override", "public", "int", "rowIndex", "(", ")", "{", "return", "(", "int", ")", "(", "i", "/", "columns", ")", ";", "}", "@", "Override", "public", "int", "columnIndex", "(", ")", "{", "return", "(", "int", ")", "(", "i", "-", "(", "(", "i", "/", "columns", ")", "*", "columns", ")", ")", ";", "}", "@", "Override", "public", "double", "get", "(", ")", "{", "return", "SparseMatrix", ".", "this", ".", "get", "(", "rowIndex", "(", ")", ",", "columnIndex", "(", ")", ")", ";", "}", "@", "Override", "public", "void", "set", "(", "double", "value", ")", "{", "SparseMatrix", ".", "this", ".", "set", "(", "rowIndex", "(", ")", ",", "columnIndex", "(", ")", ",", "value", ")", ";", "}", "@", "Override", "public", "boolean", "hasNext", "(", ")", "{", "while", "(", "i", "+", "1", "<", "limit", ")", "{", "i", "++", ";", "if", "(", "SparseMatrix", ".", "this", ".", "nonZeroAt", "(", "rowIndex", "(", ")", ",", "columnIndex", "(", ")", ")", ")", "{", "i", "--", ";", "break", ";", "}", "}", "return", "i", "+", "1", "<", "limit", ";", "}", "@", "Override", "public", "Double", "next", "(", ")", "{", "if", "(", "!", "hasNext", "(", ")", ")", "{", "throw", "new", "NoSuchElementException", "(", ")", ";", "}", "i", "++", ";", "return", "get", "(", ")", ";", "}", "}", ";", "}" ]

[ "Returns", "a", "non", "-", "zero", "row", "-", "major", "matrix", "iterator", "." ]

[ "public", "T", "createImage", "(", "int", "width", ",", "int", "height", ")", "{", "switch", "(", "family", ")", "{", "case", "GRAY", ":", "return", "(", "T", ")", "GeneralizedImageOps", ".", "createSingleBand", "(", "getImageClass", "(", ")", ",", "width", ",", "height", ")", ";", "case", "INTERLEAVED", ":", "return", "(", "T", ")", "GeneralizedImageOps", ".", "createInterleaved", "(", "getImageClass", "(", ")", ",", "width", ",", "height", ",", "numBands", ")", ";", "case", "PLANAR", ":", "return", "(", "T", ")", "new", "Planar", "(", "getImageClass", "(", ")", ",", "width", ",", "height", ",", "numBands", ")", ";", "default", ":", "throw", "new", "IllegalArgumentException", "(", "\"Type not yet supported\"", ")", ";", "}", "}" ]

[ "Creates", "a", "new", "image", "." ]

[ "private", "CmsObject", "initCmsObject", "(", "HttpServletRequest", "req", ",", "HttpServletResponse", "res", ")", "throws", "IOException", ",", "CmsException", "{", "return", "initCmsObject", "(", "req", ",", "res", ",", "true", ")", ";", "}" ]

[ "Handles", "the", "user", "authentification", "for", "each", "request", "sent", "to", "OpenCms", ".", "<p", ">" ]

[ "public", "static", "void", "multOuter", "(", "DMatrix1Row", "a", ",", "DMatrix1Row", "c", ")", "{", "c", ".", "reshape", "(", "a", ".", "numRows", ",", "a", ".", "numRows", ")", ";", "MatrixMultProduct_DDRM", ".", "outer", "(", "a", ",", "c", ")", ";", "}" ]

[ "<p", ">", "Computes", "the", "matrix", "multiplication", "outer", "product", ":", "<br", ">", "<br", ">", "c", "=", "a", "*", "a<sup", ">", "T<", "/", "sup", ">", "<br", ">", "<br", ">", "c<sub", ">", "ij<", "/", "sub", ">", "=", "&sum", ";", "<sub", ">", "k", "=", "1", ":", "m<", "/", "sub", ">", "{", "a<sub", ">", "ik<", "/", "sub", ">", "*", "a<sub", ">", "jk<", "/", "sub", ">", "}", "<", "/", "p", ">" ]

[ "public", "Bundler", "putParcelableArray", "(", "String", "key", ",", "Parcelable", "[", "]", "value", ")", "{", "bundle", ".", "putParcelableArray", "(", "key", ",", "value", ")", ";", "return", "this", ";", "}" ]

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

[ "private", "void", "loadEngines", "(", "final", "JBakeConfiguration", "config", ",", "final", "ContentStore", "db", ")", "{", "try", "{", "ClassLoader", "cl", "=", "TemplateEngines", ".", "class", ".", "getClassLoader", "(", ")", ";", "Enumeration", "<", "URL", ">", "resources", "=", "cl", ".", "getResources", "(", "\"META-INF/org.jbake.parser.TemplateEngines.properties\"", ")", ";", "while", "(", "resources", ".", "hasMoreElements", "(", ")", ")", "{", "URL", "url", "=", "resources", ".", "nextElement", "(", ")", ";", "Properties", "props", "=", "new", "Properties", "(", ")", ";", "props", ".", "load", "(", "url", ".", "openStream", "(", ")", ")", ";", "for", "(", "Map", ".", "Entry", "<", "Object", ",", "Object", ">", "entry", ":", "props", ".", "entrySet", "(", ")", ")", "{", "String", "className", "=", "(", "String", ")", "entry", ".", "getKey", "(", ")", ";", "String", "[", "]", "extensions", "=", "(", "(", "String", ")", "entry", ".", "getValue", "(", ")", ")", ".", "split", "(", "\",\"", ")", ";", "registerEngine", "(", "config", ",", "db", ",", "className", ",", "extensions", ")", ";", "}", "}", "}", "catch", "(", "IOException", "e", ")", "{", "LOGGER", ".", "error", "(", "\"Error loading engines\"", ",", "e", ")", ";", "}", "}" ]

[ "This", "method", "is", "used", "internally", "to", "load", "markup", "engines", ".", "Markup", "engines", "are", "found", "using", "descriptor", "files", "on", "classpath", "so", "adding", "an", "engine", "is", "as", "easy", "as", "adding", "a", "jar", "on", "classpath", "with", "the", "descriptor", "file", "included", "." ]

[ "private", "CommandLineCompilerConfiguration", "getBaseCompilerConfiguration", "(", "final", "Map", "<", "String", ",", "TargetInfo", ">", "targets", ")", "{", "//", "// find first target with an DevStudio C compilation", "//", "CommandLineCompilerConfiguration", "compilerConfig", ";", "//", "// get the first target and assume that it is representative", "//", "for", "(", "final", "TargetInfo", "targetInfo", ":", "targets", ".", "values", "(", ")", ")", "{", "final", "ProcessorConfiguration", "config", "=", "targetInfo", ".", "getConfiguration", "(", ")", ";", "//", "// for the first cl compiler", "//", "if", "(", "config", "instanceof", "CommandLineCompilerConfiguration", ")", "{", "compilerConfig", "=", "(", "CommandLineCompilerConfiguration", ")", "config", ";", "if", "(", "compilerConfig", ".", "getCompiler", "(", ")", "instanceof", "MsvcCCompiler", ")", "{", "return", "compilerConfig", ";", "}", "}", "}", "return", "null", ";", "}" ]

[ "Gets", "the", "first", "recognized", "compiler", "from", "the", "compilation", "targets", "." ]

[ "public", "void", "buildAnnotationTypeSignature", "(", "XMLNode", "node", ",", "Content", "annotationInfoTree", ")", "{", "StringBuilder", "modifiers", "=", "new", "StringBuilder", "(", "annotationTypeDoc", ".", "modifiers", "(", ")", "+", "\" \"", ")", ";", "writer", ".", "addAnnotationTypeSignature", "(", "Util", ".", "replaceText", "(", "modifiers", ".", "toString", "(", ")", ",", "\"interface\"", ",", "\"@interface\"", ")", ",", "annotationInfoTree", ")", ";", "}" ]

[ "Build", "the", "signature", "of", "the", "current", "annotation", "type", "." ]

[ "@", "Override", "public", "Result", "resolveFeatures", "(", "Repository", "repository", ",", "Collection", "<", "ProvisioningFeatureDefinition", ">", "kernelFeatures", ",", "Collection", "<", "String", ">", "rootFeatures", ",", "Set", "<", "String", ">", "preResolved", ",", "boolean", "allowMultipleVersions", ",", "EnumSet", "<", "ProcessType", ">", "supportedProcessTypes", ")", "{", "SelectionContext", "selectionContext", "=", "new", "SelectionContext", "(", "repository", ",", "allowMultipleVersions", ",", "supportedProcessTypes", ")", ";", "// this checks if the pre-resolved exists in the repo;", "// if one does not exist then we start over with an empty set of pre-resolved", "preResolved", "=", "checkPreResolvedExistAndSetFullName", "(", "preResolved", ",", "selectionContext", ")", ";", "// check that the root features exist and are public; remove them if not; also get the full name", "rootFeatures", "=", "checkRootsAreAccessibleAndSetFullName", "(", "new", "ArrayList", "<", "String", ">", "(", "rootFeatures", ")", ",", "selectionContext", ",", "preResolved", ")", ";", "// Always prime the selected with the pre-resolved and the root features.", "// This will ensure that the root and pre-resolved features do not conflict", "selectionContext", ".", "primeSelected", "(", "preResolved", ")", ";", "selectionContext", ".", "primeSelected", "(", "rootFeatures", ")", ";", "// Even if the feature set hasn't changed, we still need to process the auto features and add any features that need to be", "// installed/uninstalled to the list. This recursively iterates over the auto Features, as previously installed features", "// may satisfy other auto features.", "Set", "<", "String", ">", "autoFeaturesToInstall", "=", "Collections", ".", "<", "String", ">", "emptySet", "(", ")", ";", "Set", "<", "String", ">", "seenAutoFeatures", "=", "new", "HashSet", "<", "String", ">", "(", ")", ";", "Set", "<", "String", ">", "resolved", "=", "Collections", ".", "emptySet", "(", ")", ";", "do", "{", "if", "(", "!", "!", "!", "autoFeaturesToInstall", ".", "isEmpty", "(", ")", ")", "{", "// this is after the first pass; use the autoFeaturesToInstall as the roots", "rootFeatures", "=", "autoFeaturesToInstall", ";", "// Need to prime the auto features as selected", "selectionContext", ".", "primeSelected", "(", "autoFeaturesToInstall", ")", ";", "// and use the resolved as the preResolved", "preResolved", "=", "resolved", ";", "// A new resolution process will happen now along with the auto-features that match;", "// need to save off the current conflicts to be the pre resolved conflicts", "// otherwise they would get lost", "selectionContext", ".", "saveCurrentPreResolvedConflicts", "(", ")", ";", "}", "resolved", "=", "doResolveFeatures", "(", "rootFeatures", ",", "preResolved", ",", "selectionContext", ")", ";", "}", "while", "(", "!", "!", "!", "(", "autoFeaturesToInstall", "=", "processAutoFeatures", "(", "kernelFeatures", ",", "resolved", ",", "seenAutoFeatures", ",", "selectionContext", ")", ")", ".", "isEmpty", "(", ")", ")", ";", "// Finally return the selected result", "return", "selectionContext", ".", "getResult", "(", ")", ";", "}" ]

[ "/", "*", "(", "non", "-", "Javadoc", ")" ]

[ "protected", "final", "LinearGradientPaint", "createGradient", "(", "float", "x1", ",", "float", "y1", ",", "float", "x2", ",", "float", "y2", ",", "float", "[", "]", "midpoints", ",", "Color", "[", "]", "colors", ")", "{", "if", "(", "x1", "==", "x2", "&&", "y1", "==", "y2", ")", "{", "y2", "+=", ".00001f", ";", "}", "return", "new", "LinearGradientPaint", "(", "x1", ",", "y1", ",", "x2", ",", "y2", ",", "midpoints", ",", "colors", ")", ";", "}" ]

[ "Given", "parameters", "for", "creating", "a", "LinearGradientPaint", "this", "method", "will", "create", "and", "return", "a", "linear", "gradient", "paint", ".", "One", "primary", "purpose", "for", "this", "method", "is", "to", "avoid", "creating", "a", "LinearGradientPaint", "where", "the", "start", "and", "end", "points", "are", "equal", ".", "In", "such", "a", "case", "the", "end", "y", "point", "is", "slightly", "increased", "to", "avoid", "the", "overlap", "." ]

[ "public", "static", "void", "writeClass", "(", "String", "fileName", ",", "byte", "[", "]", "bytes", ")", "throws", "IOException", "{", "try", "(", "BufferedOutputStream", "out", "=", "new", "BufferedOutputStream", "(", "new", "FileOutputStream", "(", "fileName", ")", ")", ")", "{", "out", ".", "write", "(", "bytes", ")", ";", "}", "}" ]

[ "Write", "all", "class", "bytes", "to", "a", "file", "." ]

[ "protected", "void", "saveElementValue", "(", "String", "field", ",", "String", "targetKey", ",", "Page", "page", ")", "throws", "TechnicalException", ",", "FailureException", "{", "logger", ".", "debug", "(", "\"saveValueInStep: {} to {} in {}.\"", ",", "field", ",", "targetKey", ",", "page", ".", "getApplication", "(", ")", ")", ";", "String", "txt", "=", "\"\"", ";", "try", "{", "final", "WebElement", "elem", "=", "Utilities", ".", "findElement", "(", "page", ",", "field", ")", ";", "txt", "=", "elem", ".", "getAttribute", "(", "VALUE", ")", "!=", "null", "?", "elem", ".", "getAttribute", "(", "VALUE", ")", ":", "elem", ".", "getText", "(", ")", ";", "}", "catch", "(", "final", "Exception", "e", ")", "{", "new", "Result", ".", "Failure", "<>", "(", "e", ".", "getMessage", "(", ")", ",", "Messages", ".", "getMessage", "(", "Messages", ".", "FAIL_MESSAGE_UNABLE_TO_FIND_ELEMENT", ")", ",", "true", ",", "page", ".", "getCallBack", "(", ")", ")", ";", "}", "try", "{", "Context", ".", "saveValue", "(", "targetKey", ",", "txt", ")", ";", "Context", ".", "getCurrentScenario", "(", ")", ".", "write", "(", "\"SAVE \"", "+", "targetKey", "+", "\"=\"", "+", "txt", ")", ";", "}", "catch", "(", "final", "Exception", "e", ")", "{", "new", "Result", ".", "Failure", "<>", "(", "e", ".", "getMessage", "(", ")", ",", "Messages", ".", "format", "(", "Messages", ".", "getMessage", "(", "Messages", ".", "FAIL_MESSAGE_UNABLE_TO_RETRIEVE_VALUE", ")", ",", "page", ".", "getPageElementByKey", "(", "field", ")", ",", "page", ".", "getApplication", "(", ")", ")", ",", "true", ",", "page", ".", "getCallBack", "(", ")", ")", ";", "}", "}" ]

[ "Save", "value", "in", "memory", "." ]

[ "static", "ZipOutputStream", "zipEntry", "(", "ZipEntry", "entry", ",", "ZipOutputStream", "outputStream", ")", "{", "try", "{", "outputStream", ".", "putNextEntry", "(", "entry", ")", ";", "}", "catch", "(", "IOException", "cause", ")", "{", "throw", "newSystemException", "(", "cause", ",", "\"Failed to zip entry [%s]\"", ",", "entry", ".", "getName", "(", ")", ")", ";", "}", "IOUtils", ".", "doSafeIo", "(", "outputStream", "::", "closeEntry", ")", ";", "return", "outputStream", ";", "}" ]

[ "Zips", "the", "contents", "of", "the", "individual", "{", "@link", "ZipEntry", "}", "to", "the", "supplied", "{", "@link", "ZipOutputStream", "}", "." ]

[ "@", "Override", "public", "void", "rnnSetPreviousState", "(", "Map", "<", "String", ",", "INDArray", ">", "stateMap", ")", "{", "this", ".", "stateMap", ".", "clear", "(", ")", ";", "this", ".", "stateMap", ".", "putAll", "(", "stateMap", ")", ";", "}" ]

[ "Set", "the", "state", "map", ".", "Values", "set", "using", "this", "method", "will", "be", "used", "in", "next", "call", "to", "rnnTimeStep", "()" ]

[ "public", "static", "String", "unmask", "(", "final", "String", "mask", ",", "final", "String", "value", ")", "throws", "ParseException", "{", "return", "maskFormat", "(", "mask", ")", ".", "parse", "(", "value", ")", ";", "}" ]

[ "<p", ">", "Parses", "the", "given", "text", "with", "the", "mask", "specified", ".", "<", "/", "p", ">" ]

[ "public", "static", "boolean", "isValidInt", "(", "@", "Nullable", "final", "String", "integerStr", ",", "final", "int", "lowerBound", ",", "final", "int", "upperBound", ",", "final", "boolean", "includeLowerBound", ",", "final", "boolean", "includeUpperBound", ")", "{", "if", "(", "lowerBound", ">", "upperBound", ")", "{", "throw", "new", "IllegalArgumentException", "(", "ExceptionValues", ".", "INVALID_BOUNDS", ")", ";", "}", "else", "if", "(", "!", "isValidInt", "(", "integerStr", ")", ")", "{", "return", "false", ";", "}", "final", "int", "aInteger", "=", "toInteger", "(", "integerStr", ")", ";", "final", "boolean", "respectsLowerBound", "=", "includeLowerBound", "?", "lowerBound", "<=", "aInteger", ":", "lowerBound", "<", "aInteger", ";", "final", "boolean", "respectsUpperBound", "=", "includeUpperBound", "?", "aInteger", "<=", "upperBound", ":", "aInteger", "<", "upperBound", ";", "return", "respectsLowerBound", "&&", "respectsUpperBound", ";", "}" ]

[ "Given", "an", "integer", "string", "it", "checks", "if", "it", "s", "a", "valid", "integer", "(", "base", "on", "apaches", "NumberUtils", ".", "createInteger", ")", "and", "if", "it", "s", "between", "the", "lowerBound", "and", "upperBound", "." ]

[ "public", "static", "void", "extractCameraMatrices", "(", "TrifocalTensor", "tensor", ",", "DMatrixRMaj", "P2", ",", "DMatrixRMaj", "P3", ")", "{", "TrifocalExtractGeometries", "e", "=", "new", "TrifocalExtractGeometries", "(", ")", ";", "e", ".", "setTensor", "(", "tensor", ")", ";", "e", ".", "extractCamera", "(", "P2", ",", "P3", ")", ";", "}" ]

[ "<p", ">", "Extract", "the", "camera", "matrices", "up", "to", "a", "common", "projective", "transform", ".", "<", "/", "p", ">" ]

[ "public", "final", "int", "serializeDataSegment", "(", "final", "ByteBuffer", "dst", ",", "final", "int", "offset", ")", "throws", "InternetSCSIException", "{", "dataSegment", ".", "rewind", "(", ")", ";", "dst", ".", "position", "(", "offset", ")", ";", "dst", ".", "put", "(", "dataSegment", ")", ";", "return", "dataSegment", ".", "limit", "(", ")", ";", "}" ]

[ "Serializes", "the", "data", "segment", "(", "binary", "or", "key", "-", "value", "pairs", ")", "to", "a", "destination", "array", "staring", "from", "offset", "to", "write", "." ]

[ "public", "UpdateIntegrationResult", "withRequestParameters", "(", "java", ".", "util", ".", "Map", "<", "String", ",", "String", ">", "requestParameters", ")", "{", "setRequestParameters", "(", "requestParameters", ")", ";", "return", "this", ";", "}" ]

[ "<p", ">", "A", "key", "-", "value", "map", "specifying", "request", "parameters", "that", "are", "passed", "from", "the", "method", "request", "to", "the", "backend", ".", "The", "key", "is", "an", "integration", "request", "parameter", "name", "and", "the", "associated", "value", "is", "a", "method", "request", "parameter", "value", "or", "static", "value", "that", "must", "be", "enclosed", "within", "single", "quotes", "and", "pre", "-", "encoded", "as", "required", "by", "the", "backend", ".", "The", "method", "request", "parameter", "value", "must", "match", "the", "pattern", "of", "method", ".", "request", ".", "{", "location", "}", ".", "{", "name", "}", "where", "{", "location", "}", "is", "querystring", "path", "or", "header", ";", "and", "{", "name", "}", "must", "be", "a", "valid", "and", "unique", "method", "request", "parameter", "name", ".", "<", "/", "p", ">" ]

[ "@", "Nullable", "public", "JAXBContext", "getFromCache", "(", "@", "Nonnull", "final", "Package", "aPackage", ",", "@", "Nullable", "final", "ClassLoader", "aClassLoader", ")", "{", "return", "getFromCache", "(", "new", "JAXBContextCacheKey", "(", "aPackage", ",", "aClassLoader", ")", ")", ";", "}" ]

[ "Special", "overload", "with", "package", "and", "{", "@link", "ClassLoader", "}", ".", "In", "this", "case", "the", "resulting", "value", "is", "NOT", "cached!" ]

[ "private", "final", "void", "offerEntry", "(", "ChartEntry", "entry", ",", "double", "probability", ",", "int", "spanStart", ",", "int", "spanEnd", ")", "{", "HeapUtils", ".", "offer", "(", "chart", "[", "spanStart", "]", "[", "spanEnd", "]", ",", "probabilities", "[", "spanStart", "]", "[", "spanEnd", "]", ",", "chartSizes", "[", "spanEnd", "+", "(", "numTerminals", "*", "spanStart", ")", "]", ",", "entry", ",", "probability", ")", ";", "chartSizes", "[", "spanEnd", "+", "(", "numTerminals", "*", "spanStart", ")", "]", "++", ";", "totalChartSize", "++", ";", "if", "(", "chartSizes", "[", "spanEnd", "+", "(", "numTerminals", "*", "spanStart", ")", "]", ">", "beamSize", ")", "{", "HeapUtils", ".", "removeMin", "(", "chart", "[", "spanStart", "]", "[", "spanEnd", "]", ",", "probabilities", "[", "spanStart", "]", "[", "spanEnd", "]", ",", "chartSizes", "[", "spanEnd", "+", "(", "numTerminals", "*", "spanStart", ")", "]", ")", ";", "chartSizes", "[", "spanEnd", "+", "(", "numTerminals", "*", "spanStart", ")", "]", "--", ";", "totalChartSize", "--", ";", "}", "}" ]

[ "Adds", "a", "chart", "entry", "to", "the", "heap", "for", "{" ]

[ "public", "static", "br_restoreconfig", "restoreconfig", "(", "nitro_service", "client", ",", "br_restoreconfig", "resource", ")", "throws", "Exception", "{", "return", "(", "(", "br_restoreconfig", "[", "]", ")", "resource", ".", "perform_operation", "(", "client", ",", "\"restoreconfig\"", ")", ")", "[", "0", "]", ";", "}" ]

[ "<pre", ">", "Use", "this", "operation", "to", "restore", "config", "from", "file", "on", "Repeater", "Instances", ".", "<", "/", "pre", ">" ]

[ "public", "void", "expectMax", "(", "String", "name", ",", "double", "maxLength", ",", "String", "message", ")", "{", "String", "value", "=", "Optional", ".", "ofNullable", "(", "get", "(", "name", ")", ")", ".", "orElse", "(", "\"\"", ")", ";", "if", "(", "StringUtils", ".", "isNumeric", "(", "value", ")", ")", "{", "if", "(", "Double", ".", "parseDouble", "(", "value", ")", ">", "maxLength", ")", "{", "addError", "(", "name", ",", "Optional", ".", "ofNullable", "(", "message", ")", ".", "orElse", "(", "messages", ".", "get", "(", "Validation", ".", "MAX_KEY", ".", "name", "(", ")", ",", "name", ",", "maxLength", ")", ")", ")", ";", "}", "}", "else", "{", "if", "(", "value", ".", "length", "(", ")", ">", "maxLength", ")", "{", "addError", "(", "name", ",", "Optional", ".", "ofNullable", "(", "message", ")", ".", "orElse", "(", "messages", ".", "get", "(", "Validation", ".", "MAX_KEY", ".", "name", "(", ")", ",", "name", ",", "maxLength", ")", ")", ")", ";", "}", "}", "}" ]

[ "Validates", "a", "given", "field", "to", "have", "a", "maximum", "length" ]

[ "public", "Type", "asEnclosingSuper", "(", "Type", "t", ",", "Symbol", "sym", ")", "{", "switch", "(", "t", ".", "getTag", "(", ")", ")", "{", "case", "CLASS", ":", "do", "{", "Type", "s", "=", "asSuper", "(", "t", ",", "sym", ")", ";", "if", "(", "s", "!=", "null", ")", "return", "s", ";", "Type", "outer", "=", "t", ".", "getEnclosingType", "(", ")", ";", "t", "=", "(", "outer", ".", "hasTag", "(", "CLASS", ")", ")", "?", "outer", ":", "(", "t", ".", "tsym", ".", "owner", ".", "enclClass", "(", ")", "!=", "null", ")", "?", "t", ".", "tsym", ".", "owner", ".", "enclClass", "(", ")", ".", "type", ":", "Type", ".", "noType", ";", "}", "while", "(", "t", ".", "hasTag", "(", "CLASS", ")", ")", ";", "return", "null", ";", "case", "ARRAY", ":", "return", "isSubtype", "(", "t", ",", "sym", ".", "type", ")", "?", "sym", ".", "type", ":", "null", ";", "case", "TYPEVAR", ":", "return", "asSuper", "(", "t", ",", "sym", ")", ";", "case", "ERROR", ":", "return", "t", ";", "default", ":", "return", "null", ";", "}", "}" ]

[ "Return", "the", "base", "type", "of", "t", "or", "any", "of", "its", "enclosing", "types", "that", "starts", "with", "the", "given", "symbol", ".", "If", "none", "exists", "return", "null", "." ]

[ "static", "boolean", "hasMatchingToStringPair", "(", "Iterable", "<", "?", ">", "items1", ",", "Iterable", "<", "?", ">", "items2", ")", "{", "if", "(", "isEmpty", "(", "items1", ")", "||", "isEmpty", "(", "items2", ")", ")", "{", "return", "false", ";", "// Bail early to avoid calling hashCode() on the elements unnecessarily.", "}", "return", "!", "retainMatchingToString", "(", "items1", ",", "items2", ")", ".", "isEmpty", "(", ")", ";", "}" ]

[ "Returns", "true", "if", "there", "is", "a", "pair", "of", "an", "item", "from", "{", "@code", "items1", "}", "and", "one", "in", "{", "@code", "items2", "}", "that", "has", "the", "same", "{", "@code", "toString", "()", "}", "value", "without", "being", "equal", "." ]

[ "protected", "RepoBranch", "getComponentRepoBranch", "(", "Component", "component", ")", "{", "CollectorItem", "item", "=", "component", ".", "getFirstCollectorItemForType", "(", "CollectorType", ".", "SCM", ")", ";", "if", "(", "item", "==", "null", ")", "{", "logger", ".", "warn", "(", "\"Error encountered building pipeline: could not find scm collector item for dashboard.\"", ")", ";", "return", "new", "RepoBranch", "(", "\"\"", ",", "\"\"", ",", "RepoType", ".", "Unknown", ")", ";", "}", "// TODO find a better way?\r", "String", "url", "=", "(", "String", ")", "item", ".", "getOptions", "(", ")", ".", "get", "(", "\"url\"", ")", ";", "String", "branch", "=", "(", "String", ")", "item", ".", "getOptions", "(", ")", ".", "get", "(", "\"branch\"", ")", ";", "return", "new", "RepoBranch", "(", "url", ",", "branch", ",", "RepoType", ".", "Unknown", ")", ";", "}" ]

[ "Determine", "the", "SCM", "url", "and", "branch", "that", "is", "set", "for", "the", "component", ".", "Information", "is", "gathered", "with", "the", "assumption", "that", "the", "data", "is", "stored", "in", "options", ".", "url", "and", "options", ".", "branch", "." ]

[ "public", "static", "Forbidden", "of", "(", "int", "errorCode", ",", "Throwable", "cause", ")", "{", "touchPayload", "(", ")", ".", "errorCode", "(", "errorCode", ")", ".", "cause", "(", "cause", ")", ";", "return", "_INSTANCE", ";", "}" ]

[ "Returns", "a", "static", "Forbidden", "instance", "and", "set", "the", "{", "@link", "#payload", "}", "thread", "local", "with", "error", "code", "and", "cause", "specified" ]

[ "public", "static", "String", "getEnv", "(", "String", "name", ",", "String", "defaultValue", ")", "{", "Map", "<", "String", ",", "String", ">", "env", "=", "System", ".", "getenv", "(", ")", ";", "// try to get value from environment variables", "if", "(", "env", ".", "get", "(", "name", ")", "!=", "null", ")", "{", "return", "env", ".", "get", "(", "name", ")", ";", "}", "// fall back to system properties", "return", "System", ".", "getProperty", "(", "name", ",", "defaultValue", ")", ";", "}" ]

[ "returns", "values", "for", "a", "key", "in", "the", "following", "order", ":", "1", ".", "First", "checks", "environment", "variables", "2", ".", "Falls", "back", "to", "system", "properties" ]

[ "public", "File", "archiveMessage", "(", "final", "MailMessage", "message", ")", "{", "try", "{", "String", "subject", "=", "message", ".", "getSubject", "(", ")", ";", "String", "fileName", "=", "subject", "==", "null", "?", "\"no_subject\"", ":", "INVALID_FILE_NAME_CHARS", ".", "matcher", "(", "subject", ")", ".", "replaceAll", "(", "\"_\"", ")", ";", "MutableInt", "counter", "=", "counterProvider", ".", "get", "(", ")", ";", "File", "dir", "=", "new", "File", "(", "\"e-mails\"", ",", "\"unread\"", ")", ";", "File", "file", "=", "new", "File", "(", "dir", ",", "String", ".", "format", "(", "FILE_NAME_FORMAT", ",", "counter", ".", "intValue", "(", ")", ",", "fileName", ")", ")", ";", "file", "=", "new", "File", "(", "moduleArchiveDirProvider", ".", "get", "(", ")", ",", "file", ".", "getPath", "(", ")", ")", ";", "createParentDirs", "(", "file", ")", ";", "log", ".", "debug", "(", "\"Archiving e-mail: {}\"", ",", "file", ")", ";", "StrBuilder", "sb", "=", "new", "StrBuilder", "(", "500", ")", ";", "for", "(", "Entry", "<", "String", ",", "String", ">", "header", ":", "message", ".", "getHeaders", "(", ")", ".", "entries", "(", ")", ")", "{", "sb", ".", "append", "(", "header", ".", "getKey", "(", ")", ")", ".", "append", "(", "'", "'", ")", ".", "appendln", "(", "header", ".", "getValue", "(", ")", ")", ";", "}", "sb", ".", "appendln", "(", "\"\"", ")", ";", "sb", ".", "append", "(", "message", ".", "getText", "(", ")", ")", ";", "write", "(", "sb", ".", "toString", "(", ")", ",", "file", ",", "Charsets", ".", "UTF_8", ")", ";", "counter", ".", "increment", "(", ")", ";", "return", "file", ";", "}", "catch", "(", "IOException", "ex", ")", "{", "throw", "new", "MailException", "(", "\"Error archiving mail.\"", ",", "ex", ")", ";", "}", "}" ]

[ "Saves", "a", "message", "s", "test", "content", "(", "including", "headers", ")", "in", "the", "current", "module", "archive", "in", "the", "specified", "sub", "-", "directory", "relative", "to", "the", "archive", "root", ".", "File", "names", "are", "prefixed", "with", "a", "left", "-", "padded", "four", "-", "digit", "integer", "counter", "(", "format", ":", "{", "@code", "%04d_%s", ".", "txt", "}", ")", "." ]

[ "private", "Node", "tryFoldGetProp", "(", "Node", "n", ",", "Node", "left", ",", "Node", "right", ")", "{", "checkArgument", "(", "n", ".", "isGetProp", "(", ")", ")", ";", "if", "(", "left", ".", "isObjectLit", "(", ")", ")", "{", "return", "tryFoldObjectPropAccess", "(", "n", ",", "left", ",", "right", ")", ";", "}", "if", "(", "right", ".", "isString", "(", ")", "&&", "right", ".", "getString", "(", ")", ".", "equals", "(", "\"length\"", ")", ")", "{", "int", "knownLength", "=", "-", "1", ";", "switch", "(", "left", ".", "getToken", "(", ")", ")", "{", "case", "ARRAYLIT", ":", "if", "(", "mayHaveSideEffects", "(", "left", ")", ")", "{", "// Nope, can't fold this, without handling the side-effects.", "return", "n", ";", "}", "knownLength", "=", "left", ".", "getChildCount", "(", ")", ";", "break", ";", "case", "STRING", ":", "knownLength", "=", "left", ".", "getString", "(", ")", ".", "length", "(", ")", ";", "break", ";", "default", ":", "// Not a foldable case, forget it.", "return", "n", ";", "}", "checkState", "(", "knownLength", "!=", "-", "1", ")", ";", "Node", "lengthNode", "=", "IR", ".", "number", "(", "knownLength", ")", ";", "reportChangeToEnclosingScope", "(", "n", ")", ";", "n", ".", "replaceWith", "(", "lengthNode", ")", ";", "return", "lengthNode", ";", "}", "return", "n", ";", "}" ]

[ "Try", "to", "fold", "array", "-", "length", ".", "e", ".", "g", "[", "1", "2", "3", "]", ".", "length", "==", ">", "3", "[", "x", "y", "]", ".", "length", "==", ">", "2" ]

[ "@", "MOVE", "@", "Timed", "public", "void", "moveResource", "(", "@", "Suspended", "final", "AsyncResponse", "response", ",", "@", "Context", "final", "Request", "request", ",", "@", "Context", "final", "UriInfo", "uriInfo", ",", "@", "Context", "final", "HttpHeaders", "headers", ",", "@", "Context", "final", "SecurityContext", "security", ")", "{", "final", "TrellisRequest", "req", "=", "new", "TrellisRequest", "(", "request", ",", "uriInfo", ",", "headers", ",", "security", ")", ";", "final", "String", "baseUrl", "=", "getBaseUrl", "(", "req", ")", ";", "final", "IRI", "identifier", "=", "rdf", ".", "createIRI", "(", "TRELLIS_DATA_PREFIX", "+", "req", ".", "getPath", "(", ")", ")", ";", "final", "IRI", "destination", "=", "getDestination", "(", "headers", ",", "baseUrl", ")", ";", "final", "Session", "session", "=", "getSession", "(", "req", ".", "getPrincipalName", "(", ")", ")", ";", "getParent", "(", "destination", ")", ".", "thenCombine", "(", "services", ".", "getResourceService", "(", ")", ".", "get", "(", "destination", ")", ",", "this", "::", "checkResources", ")", ".", "thenCompose", "(", "parent", "->", "services", ".", "getResourceService", "(", ")", ".", "touch", "(", "parent", ".", "getIdentifier", "(", ")", ")", ")", ".", "thenCompose", "(", "future", "->", "services", ".", "getResourceService", "(", ")", ".", "get", "(", "identifier", ")", ")", ".", "thenApply", "(", "this", "::", "checkResource", ")", "// Note: all MOVE operations are recursive (Depth: infinity), hence recursiveCopy", ".", "thenAccept", "(", "res", "->", "recursiveCopy", "(", "services", ",", "session", ",", "res", ",", "destination", ",", "baseUrl", ")", ")", ".", "thenAccept", "(", "future", "->", "recursiveDelete", "(", "services", ",", "session", ",", "identifier", ",", "baseUrl", ")", ")", ".", "thenCompose", "(", "future", "->", "services", ".", "getResourceService", "(", ")", ".", "delete", "(", "Metadata", ".", "builder", "(", "identifier", ")", ".", "interactionModel", "(", "LDP", ".", "Resource", ")", ".", "build", "(", ")", ")", ")", ".", "thenCompose", "(", "future", "->", "{", "final", "TrellisDataset", "immutable", "=", "TrellisDataset", ".", "createDataset", "(", ")", ";", "services", ".", "getAuditService", "(", ")", ".", "creation", "(", "identifier", ",", "session", ")", ".", "stream", "(", ")", ".", "map", "(", "skolemizeQuads", "(", "services", ".", "getResourceService", "(", ")", ",", "baseUrl", ")", ")", ".", "forEachOrdered", "(", "immutable", "::", "add", ")", ";", "return", "services", ".", "getResourceService", "(", ")", ".", "add", "(", "identifier", ",", "immutable", ".", "asDataset", "(", ")", ")", ".", "whenComplete", "(", "(", "a", ",", "b", ")", "->", "immutable", ".", "close", "(", ")", ")", ";", "}", ")", ".", "thenAccept", "(", "future", "->", "services", ".", "getEventService", "(", ")", ".", "emit", "(", "new", "SimpleEvent", "(", "externalUrl", "(", "identifier", ",", "baseUrl", ")", ",", "session", ".", "getAgent", "(", ")", ",", "asList", "(", "PROV", ".", "Activity", ",", "AS", ".", "Delete", ")", ",", "singletonList", "(", "LDP", ".", "Resource", ")", ")", ")", ")", ".", "thenApply", "(", "future", "->", "status", "(", "NO_CONTENT", ")", ".", "build", "(", ")", ")", ".", "exceptionally", "(", "this", "::", "handleException", ")", ".", "thenApply", "(", "response", "::", "resume", ")", ";", "}" ]

[ "Move", "a", "resource", "." ]

[ "@", "NonNull", "public", "final", "<", "X", ">", "GenericType", "<", "T", ">", "where", "(", "@", "NonNull", "GenericTypeParameter", "<", "X", ">", "freeVariable", ",", "@", "NonNull", "Class", "<", "X", ">", "actualType", ")", "{", "return", "where", "(", "freeVariable", ",", "GenericType", ".", "of", "(", "actualType", ")", ")", ";", "}" ]

[ "Substitutes", "a", "free", "type", "variable", "with", "an", "actual", "type", ".", "See", "{" ]

[ "public", "synchronized", "<", "RESULT", ">", "boolean", "supports", "(", "final", "Operation", "<", "RESULT", ">", "operation", ",", "Hint", "...", "hints", ")", "{", "final", "Frame", "<", "RESULT", ">", "frame", "=", "new", "Frame", "<>", "(", "Phase", ".", "SUPPORT_CHECK", ",", "operation", ",", "hints", ")", ";", "try", "{", "return", "handle", "(", "frame", ")", ";", "}", "catch", "(", "Frame", ".", "RecursionException", "e", ")", "{", "return", "false", ";", "}", "}" ]

[ "Learn", "whether", "{", "@code", "operation", "}", "is", "supported", "by", "this", "context", "." ]

[ "public", "static", "Action0", "fromRunnable", "(", "Runnable", "run", ",", "Worker", "inner", ")", "{", "if", "(", "run", "==", "null", ")", "{", "throw", "new", "NullPointerException", "(", "\"run\"", ")", ";", "}", "return", "new", "ActionWrappingRunnable", "(", "run", ",", "inner", ")", ";", "}" ]

[ "Converts", "a", "runnable", "instance", "into", "an", "Action0", "instance", "." ]

[ "public", "FessMessages", "addConstraintsTypeAnyMessage", "(", "String", "property", ",", "String", "propertyType", ")", "{", "assertPropertyNotNull", "(", "property", ")", ";", "add", "(", "property", ",", "new", "UserMessage", "(", "CONSTRAINTS_TypeAny_MESSAGE", ",", "propertyType", ")", ")", ";", "return", "this", ";", "}" ]

[ "Add", "the", "created", "action", "message", "for", "the", "key", "constraints", ".", "TypeAny", ".", "message", "with", "parameters", ".", "<pre", ">", "message", ":", "{", "item", "}", "cannot", "convert", "as", "{", "propertyType", "}", ".", "<", "/", "pre", ">" ]

[ "public", "boolean", "addAll", "(", "int", "index", ",", "FloatArray", "items", ")", "{", "if", "(", "index", "<", "0", "||", "index", ">", "size", ")", "{", "throw", "new", "IndexOutOfBoundsException", "(", ")", ";", "}", "ensureCapacity", "(", "size", "+", "items", ".", "size", ")", ";", "if", "(", "index", "<", "size", ")", "{", "for", "(", "int", "i", "=", "size", "-", "1", ";", "i", ">=", "index", ";", "i", "--", ")", "{", "elements", "[", "i", "+", "items", ".", "size", "]", "=", "elements", "[", "i", "]", ";", "}", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "items", ".", "size", ";", "i", "++", ")", "{", "elements", "[", "index", "++", "]", "=", "items", ".", "elements", "[", "i", "]", ";", "}", "size", "+=", "items", ".", "size", ";", "return", "items", ".", "size", ">", "0", ";", "}" ]

[ "Inserts", "values", "into", "the", "array", "at", "the", "specified", "index", "." ]

[ "public", "static", "void", "decodeTo", "(", "InputStream", "in", ",", "MultiMap", "<", "String", ">", "map", ",", "String", "charset", ",", "int", "maxLength", ",", "int", "maxKeys", ")", "throws", "IOException", "{", "if", "(", "charset", "==", "null", ")", "{", "if", "(", "ENCODING", ".", "equals", "(", "StandardCharsets", ".", "UTF_8", ")", ")", "decodeUtf8To", "(", "in", ",", "map", ",", "maxLength", ",", "maxKeys", ")", ";", "else", "decodeTo", "(", "in", ",", "map", ",", "ENCODING", ",", "maxLength", ",", "maxKeys", ")", ";", "}", "else", "if", "(", "StringUtils", ".", "__UTF8", ".", "equalsIgnoreCase", "(", "charset", ")", ")", "decodeUtf8To", "(", "in", ",", "map", ",", "maxLength", ",", "maxKeys", ")", ";", "else", "if", "(", "StringUtils", ".", "__ISO_8859_1", ".", "equalsIgnoreCase", "(", "charset", ")", ")", "decode88591To", "(", "in", ",", "map", ",", "maxLength", ",", "maxKeys", ")", ";", "else", "if", "(", "StringUtils", ".", "__UTF16", ".", "equalsIgnoreCase", "(", "charset", ")", ")", "decodeUtf16To", "(", "in", ",", "map", ",", "maxLength", ",", "maxKeys", ")", ";", "else", "decodeTo", "(", "in", ",", "map", ",", "Charset", ".", "forName", "(", "charset", ")", ",", "maxLength", ",", "maxKeys", ")", ";", "}" ]

[ "Decoded", "parameters", "to", "Map", "." ]

[ "public", "void", "setUserPassword", "(", "String", "userName", ",", "String", "password", ")", "{", "ProtocolHeader", "header", "=", "new", "ProtocolHeader", "(", ")", ";", "header", ".", "setType", "(", "ProtocolType", ".", "SetUserPassword", ")", ";", "byte", "[", "]", "secret", "=", "null", ";", "if", "(", "password", "!=", "null", "&&", "!", "password", ".", "isEmpty", "(", ")", ")", "{", "secret", "=", "ObfuscatUtil", ".", "base64Encode", "(", "password", ".", "getBytes", "(", ")", ")", ";", "}", "SetUserPasswordProtocol", "p", "=", "new", "SetUserPasswordProtocol", "(", "userName", ",", "secret", ")", ";", "connection", ".", "submitRequest", "(", "header", ",", "p", ",", "null", ")", ";", "}" ]

[ "Set", "user", "password", "." ]

[ "public", "void", "promptEquals", "(", "double", "seconds", ",", "String", "expectedPromptText", ")", "{", "try", "{", "double", "timeTook", "=", "popup", "(", "seconds", ")", ";", "timeTook", "=", "popupEquals", "(", "seconds", "-", "timeTook", ",", "expectedPromptText", ")", ";", "checkPromptEquals", "(", "expectedPromptText", ",", "seconds", ",", "timeTook", ")", ";", "}", "catch", "(", "TimeoutException", "e", ")", "{", "checkPromptEquals", "(", "expectedPromptText", ",", "seconds", ",", "seconds", ")", ";", "}", "}" ]

[ "Waits", "up", "to", "the", "provided", "wait", "time", "for", "a", "prompt", "present", "on", "the", "page", "has", "content", "equal", "to", "the", "expected", "text", ".", "This", "information", "will", "be", "logged", "and", "recorded", "with", "a", "screenshot", "for", "traceability", "and", "added", "debugging", "support", "." ]

[ "public", "static", "String", "toUpperCase", "(", "Locale", "locale", ",", "String", "str", ")", "{", "return", "toUpperCase", "(", "getCaseLocale", "(", "locale", ")", ",", "str", ")", ";", "}" ]

[ "Returns", "the", "uppercase", "version", "of", "the", "argument", "string", ".", "Casing", "is", "dependent", "on", "the", "argument", "locale", "and", "context", "-", "sensitive", "." ]

[ "private", "void", "getStrings", "(", "HashSet", "<", "String", ">", "strHashSet", ",", "SearchCondition", "searchCondition", ",", "String", "searchConditionString", ",", "String", "prefixString", ",", "TreeMap", "<", "Character", ",", "MDAGNode", ">", "transitionTreeMap", ")", "{", "//Traverse all the valid _transition paths beginning from each _transition in transitionTreeMap, inserting the", "//corresponding Strings in to strHashSet that have the relationship with conditionString denoted by searchCondition", "for", "(", "Entry", "<", "Character", ",", "MDAGNode", ">", "transitionKeyValuePair", ":", "transitionTreeMap", ".", "entrySet", "(", ")", ")", "{", "String", "newPrefixString", "=", "prefixString", "+", "transitionKeyValuePair", ".", "getKey", "(", ")", ";", "MDAGNode", "currentNode", "=", "transitionKeyValuePair", ".", "getValue", "(", ")", ";", "if", "(", "currentNode", ".", "isAcceptNode", "(", ")", "&&", "searchCondition", ".", "satisfiesCondition", "(", "newPrefixString", ",", "searchConditionString", ")", ")", "strHashSet", ".", "add", "(", "newPrefixString", ")", ";", "//Recursively call this to traverse all the valid _transition paths from currentNode", "getStrings", "(", "strHashSet", ",", "searchCondition", ",", "searchConditionString", ",", "newPrefixString", ",", "currentNode", ".", "getOutgoingTransitions", "(", ")", ")", ";", "}", "/////", "}" ]

[ "Retrieves", "Strings", "corresponding", "to", "all", "valid", "_transition", "paths", "from", "a", "given", "node", "that", "satisfy", "a", "given", "condition", "." ]

[ "public", "boolean", "isVisited", "(", "int", "from", ",", "int", "upTo", ")", "{", "if", "(", "checkBounds", "(", "from", ")", "&&", "checkBounds", "(", "upTo", "-", "1", ")", ")", "{", "// perform the visit check", "//", "for", "(", "int", "i", "=", "from", ";", "i", "<", "upTo", ";", "i", "++", ")", "{", "if", "(", "ONE", "==", "this", ".", "registry", "[", "i", "]", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}", "else", "{", "throw", "new", "RuntimeException", "(", "\"The location \"", "+", "from", "+", "\",\"", "+", "upTo", "+", "\" out of bounds [0,\"", "+", "(", "this", ".", "registry", ".", "length", "-", "1", ")", "+", "\"]\"", ")", ";", "}", "}" ]

[ "Check", "if", "the", "interval", "and", "its", "boundaries", "were", "visited", "." ]

[ "protected", "final", "char", "skipEquals", "(", "String", "name", ",", "String", "eofMsg", ")", "throws", "XMLStreamException", "{", "char", "c", "=", "getNextInCurrAfterWS", "(", "eofMsg", ")", ";", "if", "(", "c", "!=", "'", "'", ")", "{", "throwUnexpectedChar", "(", "c", ",", "\" in xml declaration; expected '=' to follow pseudo-attribute '\"", "+", "name", "+", "\"'\"", ")", ";", "}", "// trailing space?", "return", "getNextInCurrAfterWS", "(", "eofMsg", ")", ";", "}" ]

[ "Method", "that", "checks", "that", "input", "following", "is", "of", "form", "[", "S", "]", "*", "=", "[", "S", "]", "*", "(", "as", "per", "XML", "specs", "production", "#25", ")", ".", "Will", "push", "back", "non", "-", "white", "space", "characters", "as", "necessary", "in", "case", "no", "equals", "char", "is", "encountered", "." ]

[ "void", "triggerSessionRequested", "(", "Jingle", "initJin", ")", "{", "JingleSessionRequestListener", "[", "]", "jingleSessionRequestListeners", ";", "// Make a synchronized copy of the listenerJingles", "synchronized", "(", "this", ".", "jingleSessionRequestListeners", ")", "{", "jingleSessionRequestListeners", "=", "new", "JingleSessionRequestListener", "[", "this", ".", "jingleSessionRequestListeners", ".", "size", "(", ")", "]", ";", "this", ".", "jingleSessionRequestListeners", ".", "toArray", "(", "jingleSessionRequestListeners", ")", ";", "}", "// ... and let them know of the event", "JingleSessionRequest", "request", "=", "new", "JingleSessionRequest", "(", "this", ",", "initJin", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "jingleSessionRequestListeners", ".", "length", ";", "i", "++", ")", "{", "jingleSessionRequestListeners", "[", "i", "]", ".", "sessionRequested", "(", "request", ")", ";", "}", "}" ]

[ "Activates", "the", "listenerJingles", "on", "a", "Jingle", "session", "request", "." ]

[ "public", "static", "GaussianRadialBasis", "learnGaussianRadialBasis", "(", "double", "[", "]", "[", "]", "x", ",", "double", "[", "]", "[", "]", "centers", ")", "{", "int", "k", "=", "centers", ".", "length", ";", "KMeans", "kmeans", "=", "new", "KMeans", "(", "x", ",", "k", ",", "10", ")", ";", "System", ".", "arraycopy", "(", "kmeans", ".", "centroids", "(", ")", ",", "0", ",", "centers", ",", "0", ",", "k", ")", ";", "double", "r0", "=", "0.0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "k", ";", "i", "++", ")", "{", "for", "(", "int", "j", "=", "0", ";", "j", "<", "i", ";", "j", "++", ")", "{", "double", "d", "=", "Math", ".", "distance", "(", "centers", "[", "i", "]", ",", "centers", "[", "j", "]", ")", ";", "if", "(", "r0", "<", "d", ")", "{", "r0", "=", "d", ";", "}", "}", "}", "r0", "/=", "Math", ".", "sqrt", "(", "2", "*", "k", ")", ";", "return", "new", "GaussianRadialBasis", "(", "r0", ")", ";", "}" ]

[ "Learns", "Gaussian", "RBF", "function", "and", "centers", "from", "data", ".", "The", "centers", "are", "chosen", "as", "the", "centroids", "of", "K", "-", "Means", ".", "Let", "d<sub", ">", "max<", "/", "sub", ">", "be", "the", "maximum", "distance", "between", "the", "chosen", "centers", "the", "standard", "deviation", "(", "i", ".", "e", ".", "width", ")", "of", "Gaussian", "radial", "basis", "function", "is", "d<sub", ">", "max<", "/", "sub", ">", "/", "sqrt", "(", "2", "*", "k", ")", "where", "k", "is", "number", "of", "centers", ".", "This", "choice", "would", "be", "close", "to", "the", "optimal", "solution", "if", "the", "data", "were", "uniformly", "distributed", "in", "the", "input", "space", "leading", "to", "a", "uniform", "distribution", "of", "centroids", "." ]

[ "public", "static", "String", "regexpExtract", "(", "String", "str", ",", "String", "regex", ",", "int", "extractIndex", ")", "{", "if", "(", "extractIndex", "<", "0", ")", "{", "return", "null", ";", "}", "try", "{", "Matcher", "m", "=", "REGEXP_PATTERN_CACHE", ".", "get", "(", "regex", ")", ".", "matcher", "(", "str", ")", ";", "if", "(", "m", ".", "find", "(", ")", ")", "{", "MatchResult", "mr", "=", "m", ".", "toMatchResult", "(", ")", ";", "return", "mr", ".", "group", "(", "extractIndex", ")", ";", "}", "return", "null", ";", "}", "catch", "(", "Exception", "e", ")", "{", "LOG", ".", "error", "(", "String", ".", "format", "(", "\"Exception in regexpExtract('%s', '%s', '%d')\"", ",", "str", ",", "regex", ",", "extractIndex", ")", ",", "e", ")", ";", "return", "null", ";", "}", "}" ]

[ "Returns", "a", "string", "extracted", "with", "a", "specified", "regular", "expression", "and", "a", "regex", "match", "group", "index", "." ]

[ "public", "static", "<", "T", ">", "T", "getIfExists", "(", "Bean", "<", "T", ">", "bean", ",", "BeanManagerImpl", "manager", ")", "{", "return", "getStrategy", "(", "bean", ")", ".", "getIfExists", "(", "bean", ",", "manager", ")", ";", "}" ]

[ "Shortcut", "for", "obtaining", "contextual", "instances", "with", "semantics", "equivalent", "to", ":", "<code", ">", "manager", ".", "getContext", "(", "bean", ".", "getScope", "()", ")", ".", "get", "(", "bean", ")", ";", "<", "/", "code", ">" ]