Datasets:

---

stojchet

/

base_prediction_dataset

like 0

[ "public", "static", "int", "countGC", "(", "Sequence", "<", "NucleotideCompound", ">", "sequence", ")", "{", "CompoundSet", "<", "NucleotideCompound", ">", "cs", "=", "sequence", ".", "getCompoundSet", "(", ")", ";", "NucleotideCompound", "G", "=", "cs", ".", "getCompoundForString", "(", "\"G\"", ")", ";", "NucleotideCompound", "C", "=", "cs", ".", "getCompoundForString", "(", "\"C\"", ")", ";", "NucleotideCompound", "g", "=", "cs", ".", "getCompoundForString", "(", "\"g\"", ")", ";", "NucleotideCompound", "c", "=", "cs", ".", "getCompoundForString", "(", "\"c\"", ")", ";", "return", "countCompounds", "(", "sequence", ",", "G", ",", "C", ",", "g", ",", "c", ")", ";", "}" ]

[ "Returns", "the", "count", "of", "GC", "in", "the", "given", "sequence" ]

[ "static", "IOException", "secureConnectionException", "(", "String", "description", ")", "{", "try", "{", "Class", "<", "?", ">", "sslExceptionClass", "=", "Class", ".", "forName", "(", "\"javax.net.ssl.SSLException\"", ")", ";", "Constructor", "<", "?", ">", "constructor", "=", "sslExceptionClass", ".", "getConstructor", "(", "String", ".", "class", ")", ";", "return", "(", "IOException", ")", "constructor", ".", "newInstance", "(", "description", ")", ";", "}", "catch", "(", "ClassNotFoundException", "e", ")", "{", "return", "new", "IOException", "(", "description", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "AssertionError", "(", "\"unexpected exception\"", ",", "e", ")", ";", "}", "}" ]

[ "Returns", "an", "SSLException", "if", "that", "class", "is", "linked", "into", "the", "application", "otherwise", "IOException", "." ]

[ "public", "void", "exportView", "(", "Node", "node", ",", "OutputStream", "os", ",", "boolean", "skipBinary", ",", "boolean", "noRecurse", ")", "throws", "IOException", ",", "RepositoryException", "{", "try", "{", "exportView", "(", "node", ",", "new", "StreamingContentHandler", "(", "os", ",", "UNEXPORTABLE_NAMESPACES", ")", ",", "skipBinary", ",", "noRecurse", ")", ";", "os", ".", "flush", "(", ")", ";", "}", "catch", "(", "SAXException", "se", ")", "{", "throw", "new", "RepositoryException", "(", "se", ")", ";", "}", "}" ]

[ "Exports", "<code", ">", "node<", "/", "code", ">", "(", "or", "the", "subtree", "rooted", "at", "<code", ">", "node<", "/", "code", ">", ")", "into", "an", "XML", "document", "that", "is", "written", "to", "<code", ">", "os<", "/", "code", ">", "." ]

[ "public", "static", "Structure", "getBiologicalAssembly", "(", "String", "pdbId", ",", "int", "biolAssemblyNr", ")", "throws", "IOException", ",", "StructureException", "{", "return", "getBiologicalAssembly", "(", "pdbId", ",", "biolAssemblyNr", ",", "AtomCache", ".", "DEFAULT_BIOASSEMBLY_STYLE", ")", ";", "}" ]

[ "Returns", "the", "biological", "assembly", "for", "the", "given", "PDB", "id", "and", "bioassembly", "identifier", "using", "multiModel", "=", "{" ]

[ "public", "Observable", "<", "Void", ">", "deleteAsync", "(", "String", "resourceGroupName", ",", "String", "locationName", ",", "String", "failoverGroupName", ")", "{", "return", "deleteWithServiceResponseAsync", "(", "resourceGroupName", ",", "locationName", ",", "failoverGroupName", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "Void", ">", ",", "Void", ">", "(", ")", "{", "@", "Override", "public", "Void", "call", "(", "ServiceResponse", "<", "Void", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Deletes", "a", "failover", "group", "." ]

[ "public", "<", "T", ">", "T", "convertValue", "(", "Object", "object", ",", "JavaType", "toValueTypeRef", ")", "{", "return", "this", ".", "mapper", ".", "convertValue", "(", "object", ",", "toValueTypeRef", ")", ";", "}" ]

[ "Converts", "one", "object", "into", "another", "." ]

[ "public", "Collection", "<", "Effort", ">", "effortRecords", "(", "EffortFilter", "filter", ")", "{", "return", "get", "(", "Effort", ".", "class", ",", "(", "filter", "!=", "null", ")", "?", "filter", ":", "new", "EffortFilter", "(", ")", ")", ";", "}" ]

[ "Get", "effort", "records", "filtered", "by", "the", "criteria", "specified", "in", "the", "passed", "in", "filter", "." ]

[ "public", "void", "setAlgorithm", "(", "KeyAgreementType", "dh", ")", "{", "log", "(", "\"DH algorithm set: \"", "+", "getDHName", "(", "dhMode", ")", "+", "\" -> \"", "+", "getDHName", "(", "dh", ")", ")", ";", "try", "{", "if", "(", "dhMode", "!=", "null", "&&", "dh", ".", "keyType", "==", "dhMode", ".", "keyType", ")", "return", ";", "dhMode", "=", "dh", ";", "switch", "(", "dhMode", ".", "keyType", ")", "{", "case", "KeyAgreementType", ".", "DH_MODE_DH3K", ":", "byte", "[", "]", "dhGen", "=", "new", "byte", "[", "384", "]", ";", "Arrays", ".", "zero", "(", "dhGen", ")", ";", "dhGen", "[", "383", "]", "=", "0x02", ";", "dhSystem", "=", "new", "DHCryptoSystem", "(", "DH_PRIME", ",", "dhGen", ")", ";", "dhKeyPair", "=", "dhSystem", ".", "createDHKeyPair", "(", ")", ";", "clearEcdh", "(", ")", ";", "break", ";", "case", "KeyAgreementType", ".", "DH_MODE_EC25", ":", "ecSystem", "=", "new", "ECCryptoSystem", "(", "ECCryptoSystem", ".", "EC256R1", ")", ";", "ecKeyPair", "=", "ecSystem", ".", "createECKeyPair", "(", ")", ";", "clearDh", "(", ")", ";", "break", ";", "case", "KeyAgreementType", ".", "DH_MODE_EC38", ":", "default", ":", "ecSystem", "=", "new", "ECCryptoSystem", "(", "ECCryptoSystem", ".", "EC384R1", ")", ";", "ecKeyPair", "=", "ecSystem", ".", "createECKeyPair", "(", ")", ";", "clearDh", "(", ")", ";", "break", ";", "}", "}", "catch", "(", "InvalidCryptoSystemException", "e", ")", "{", "// TODO Auto-generated catch block\r", "e", ".", "printStackTrace", "(", ")", ";", "}", "catch", "(", "UnsupportedCryptoSystemException", "e", ")", "{", "// TODO Auto-generated catch block\r", "e", ".", "printStackTrace", "(", ")", ";", "}", "catch", "(", "CryptoTokenException", "e", ")", "{", "// TODO Auto-generated catch block\r", "e", ".", "printStackTrace", "(", ")", ";", "}", "catch", "(", "CryptoUnsupportedOperationException", "e", ")", "{", "// TODO Auto-generated catch block\r", "e", ".", "printStackTrace", "(", ")", ";", "}", "}" ]

[ "DH3K", "RIM", "implementation", "is", "currently", "buggy", "and", "DOES", "NOT", "WORK!!!" ]

[ "@", "Override", "public", "Subject", "performLogin", "(", "String", "jaasEntryName", ",", "CallbackHandler", "callbackHandler", ",", "Subject", "partialSubject", ")", "throws", "LoginException", "{", "LoginContext", "loginContext", "=", "null", ";", "loginContext", "=", "doLoginContext", "(", "jaasEntryName", ",", "callbackHandler", ",", "partialSubject", ")", ";", "return", "(", "loginContext", "==", "null", "?", "null", ":", "loginContext", ".", "getSubject", "(", ")", ")", ";", "}" ]

[ "Performs", "a", "JAAS", "login", "." ]

[ "public", "static", "MethodAnnotation", "fromCalledMethod", "(", "String", "className", ",", "String", "methodName", ",", "String", "methodSig", ",", "boolean", "isStatic", ")", "{", "MethodAnnotation", "methodAnnotation", "=", "fromForeignMethod", "(", "className", ",", "methodName", ",", "methodSig", ",", "isStatic", ")", ";", "methodAnnotation", ".", "setDescription", "(", "METHOD_CALLED", ")", ";", "return", "methodAnnotation", ";", "}" ]

[ "Create", "a", "MethodAnnotation", "from", "a", "method", "that", "is", "not", "directly", "accessible", ".", "We", "will", "use", "the", "repository", "to", "try", "to", "find", "its", "class", "in", "order", "to", "populate", "the", "information", "as", "fully", "as", "possible", "." ]

[ "@", "Override", "public", "void", "paintIcon", "(", "Component", "c", ",", "Graphics", "g", ",", "int", "x", ",", "int", "y", ")", "{", "Graphics2D", "g2", "=", "(", "Graphics2D", ")", "g", ".", "create", "(", ")", ";", "g2", ".", "setComposite", "(", "AlphaComposite", ".", "SrcAtop", ".", "derive", "(", "alpha", ")", ")", ";", "icon", ".", "paintIcon", "(", "c", ",", "g2", ",", "x", ",", "y", ")", ";", "g2", ".", "dispose", "(", ")", ";", "}" ]

[ "Paints", "the", "wrapped", "icon", "with", "this", "<CODE", ">", "AlphaIcon<", "/", "CODE", ">", "s", "transparency", "." ]

[ "private", "Element", "createElement", "(", "final", "Document", "theTargetDocument", ",", "final", "String", "theName", ")", "{", "final", "Element", "indexEntryNode", "=", "theTargetDocument", ".", "createElementNS", "(", "this", ".", "namespace_url", ",", "theName", ")", ";", "indexEntryNode", ".", "setPrefix", "(", "this", ".", "prefix", ")", ";", "return", "indexEntryNode", ";", "}" ]

[ "Creates", "element", "with", "prefix", "in", "namespace_url", "with", "given", "name", "for", "the", "target", "document" ]

[ "public", "static", "String", "getTemporaryPathRoot", "(", "Configuration", "conf", ",", "@", "Nullable", "JobID", "jobId", ")", "throws", "IOException", "{", "// Try using the temporary gcs path.", "String", "pathRoot", "=", "conf", ".", "get", "(", "BigQueryConfiguration", ".", "TEMP_GCS_PATH_KEY", ")", ";", "if", "(", "Strings", ".", "isNullOrEmpty", "(", "pathRoot", ")", ")", "{", "checkNotNull", "(", "jobId", ",", "\"jobId is required if '%s' is not set\"", ",", "TEMP_GCS_PATH_KEY", ")", ";", "logger", ".", "atInfo", "(", ")", ".", "log", "(", "\"Fetching key '%s' since '%s' isn't set explicitly.\"", ",", "GCS_BUCKET_KEY", ",", "TEMP_GCS_PATH_KEY", ")", ";", "String", "gcsBucket", "=", "conf", ".", "get", "(", "GCS_BUCKET_KEY", ")", ";", "if", "(", "Strings", ".", "isNullOrEmpty", "(", "gcsBucket", ")", ")", "{", "throw", "new", "IOException", "(", "\"Must supply a value for configuration setting: \"", "+", "GCS_BUCKET_KEY", ")", ";", "}", "pathRoot", "=", "String", ".", "format", "(", "\"gs://%s/hadoop/tmp/bigquery/%s\"", ",", "gcsBucket", ",", "jobId", ")", ";", "}", "logger", ".", "atInfo", "(", ")", ".", "log", "(", "\"Using working path: '%s'\"", ",", "pathRoot", ")", ";", "Path", "workingPath", "=", "new", "Path", "(", "pathRoot", ")", ";", "FileSystem", "fs", "=", "workingPath", ".", "getFileSystem", "(", "conf", ")", ";", "Preconditions", ".", "checkState", "(", "fs", "instanceof", "GoogleHadoopFileSystemBase", ",", "\"Export FS must derive from GoogleHadoopFileSystemBase.\"", ")", ";", "return", "pathRoot", ";", "}" ]

[ "Resolves", "to", "provided", "{", "@link", "#TEMP_GCS_PATH_KEY", "}", "or", "fallbacks", "to", "a", "temporary", "path", "based", "on", "{", "@link", "#GCS_BUCKET_KEY", "}", "and", "{", "@code", "jobId", "}", "." ]

[ "public", "void", "endElement", "(", "String", "namespaceURI", ",", "String", "localName", ",", "String", "qName", ")", "throws", "SAXException", "{", "if", "(", "m_firstTagNotEmitted", ")", "{", "flush", "(", ")", ";", "if", "(", "namespaceURI", "==", "null", "&&", "m_firstElementURI", "!=", "null", ")", "namespaceURI", "=", "m_firstElementURI", ";", "if", "(", "localName", "==", "null", "&&", "m_firstElementLocalName", "!=", "null", ")", "localName", "=", "m_firstElementLocalName", ";", "}", "m_handler", ".", "endElement", "(", "namespaceURI", ",", "localName", ",", "qName", ")", ";", "}" ]

[ "Pass", "the", "call", "on", "to", "the", "underlying", "handler" ]

[ "public", "WikiPage", "updatePage", "(", "Object", "projectIdOrPath", ",", "String", "slug", ",", "String", "title", ",", "String", "content", ")", "throws", "GitLabApiException", "{", "GitLabApiForm", "formData", "=", "new", "GitLabApiForm", "(", ")", ".", "withParam", "(", "\"title\"", ",", "title", ")", ".", "withParam", "(", "\"slug\"", ",", "slug", ",", "true", ")", ".", "withParam", "(", "\"content\"", ",", "content", ")", ";", "Response", "response", "=", "put", "(", "Response", ".", "Status", ".", "OK", ",", "formData", ".", "asMap", "(", ")", ",", "\"projects\"", ",", "getProjectIdOrPath", "(", "projectIdOrPath", ")", ",", "\"wikis\"", ",", "slug", ")", ";", "return", "(", "response", ".", "readEntity", "(", "WikiPage", ".", "class", ")", ")", ";", "}" ]

[ "Updates", "an", "existing", "project", "wiki", "page", ".", "The", "user", "must", "have", "permission", "to", "change", "an", "existing", "wiki", "page", "." ]

[ "public", "static", "void", "executeIn", "(", "ClassLoader", "loader", ",", "Runnable", "task", ")", "throws", "Exception", "{", "if", "(", "task", "==", "null", ")", "return", ";", "if", "(", "log", ".", "isLoggable", "(", "Level", ".", "FINE", ")", ")", "{", "log", ".", "fine", "(", "\"ClassLoader [\"", "+", "loader", "+", "\"] task began.\"", ")", ";", "}", "ClassLoader", "original", "=", "SecurityActions", ".", "getContextClassLoader", "(", ")", ";", "try", "{", "SecurityActions", ".", "setContextClassLoader", "(", "loader", ")", ";", "task", ".", "run", "(", ")", ";", "}", "finally", "{", "SecurityActions", ".", "setContextClassLoader", "(", "original", ")", ";", "if", "(", "log", ".", "isLoggable", "(", "Level", ".", "FINE", ")", ")", "{", "log", ".", "fine", "(", "\"ClassLoader [\"", "+", "loader", "+", "\"] task ended.\"", ")", ";", "}", "}", "}" ]

[ "Execute", "the", "given", "{" ]

[ "public", "static", "Stream", "<", "Link", ">", "getMementoLinks", "(", "final", "String", "identifier", ",", "final", "List", "<", "VersionRange", ">", "mementos", ")", "{", "return", "concat", "(", "getTimeMap", "(", "identifier", ",", "mementos", ".", "stream", "(", ")", ")", ",", "mementos", ".", "stream", "(", ")", ".", "map", "(", "mementoToLink", "(", "identifier", ")", ")", ")", ";", "}" ]

[ "Retrieve", "all", "of", "the", "Memento", "-", "related", "link", "headers", "given", "a", "stream", "of", "VersionRange", "objects" ]

[ "public", "static", "void", "applyMetaCriteriaToQuery", "(", "Query", "query", ",", "QueryWhere", "queryWhere", ")", "{", "if", "(", "queryWhere", ".", "getCount", "(", ")", "!=", "null", ")", "{", "query", ".", "setMaxResults", "(", "queryWhere", ".", "getCount", "(", ")", ")", ";", "}", "if", "(", "queryWhere", ".", "getOffset", "(", ")", "!=", "null", ")", "{", "query", ".", "setFirstResult", "(", "queryWhere", ".", "getOffset", "(", ")", ")", ";", "}", "}" ]

[ "Small", "method", "to", "apply", "the", "meta", "criteria", "from", "the", "{" ]

[ "public", "void", "editComment", "(", "String", "commentId", ",", "String", "commentText", ")", "throws", "FlickrException", "{", "Map", "<", "String", ",", "Object", ">", "parameters", "=", "new", "HashMap", "<", "String", ",", "Object", ">", "(", ")", ";", "parameters", ".", "put", "(", "\"method\"", ",", "METHOD_EDIT_COMMENT", ")", ";", "parameters", ".", "put", "(", "\"comment_id\"", ",", "commentId", ")", ";", "parameters", ".", "put", "(", "\"comment_text\"", ",", "commentText", ")", ";", "// Note: This method requires an HTTP POST request.\r", "Response", "response", "=", "transportAPI", ".", "post", "(", "transportAPI", ".", "getPath", "(", ")", ",", "parameters", ",", "apiKey", ",", "sharedSecret", ")", ";", "if", "(", "response", ".", "isError", "(", ")", ")", "{", "throw", "new", "FlickrException", "(", "response", ".", "getErrorCode", "(", ")", ",", "response", ".", "getErrorMessage", "(", ")", ")", ";", "}", "// This method has no specific response - It returns an empty\r", "// sucess response if it completes without error.\r", "}" ]

[ "Edit", "the", "text", "of", "a", "comment", "as", "the", "currently", "authenticated", "user", "." ]

[ "private", "void", "storeArgs", "(", "Constructor", "constructor", ",", "Array", "conArgs", ")", "{", "Class", "[", "]", "pmt", "=", "constructor", ".", "getParameterTypes", "(", ")", ";", "Object", "o", "=", "conArgs", ".", "get", "(", "pmt", ".", "length", "+", "1", ",", "null", ")", ";", "Constructor", "[", "]", "args", ";", "if", "(", "o", "==", "null", ")", "{", "args", "=", "new", "Constructor", "[", "1", "]", ";", "conArgs", ".", "setEL", "(", "pmt", ".", "length", "+", "1", ",", "args", ")", ";", "}", "else", "{", "Constructor", "[", "]", "cs", "=", "(", "Constructor", "[", "]", ")", "o", ";", "args", "=", "new", "Constructor", "[", "cs", ".", "length", "+", "1", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "cs", ".", "length", ";", "i", "++", ")", "{", "args", "[", "i", "]", "=", "cs", "[", "i", "]", ";", "}", "conArgs", ".", "setEL", "(", "pmt", ".", "length", "+", "1", ",", "args", ")", ";", "}", "args", "[", "args", ".", "length", "-", "1", "]", "=", "constructor", ";", "}" ]

[ "seperate", "and", "store", "the", "different", "arguments", "of", "one", "constructor" ]

[ "public", "static", "void", "setPRNGProvider", "(", "String", "prngName", ",", "String", "packageName", ")", "{", "VersionFourGenerator", ".", "usePRNG", "=", "prngName", ";", "VersionFourGenerator", ".", "usePRNGPackage", "=", "packageName", ";", "VersionFourGenerator", ".", "secureRandom", "=", "null", ";", "}" ]

[ "<p", ">", "Allows", "clients", "to", "set", "the", "pseudo", "-", "random", "number", "generator", "implementation", "used", "when", "generating", "a", "version", "four", "uuid", "with", "the", "secure", "option", ".", "The", "secure", "option", "uses", "a", "<code", ">", "SecureRandom<", "/", "code", ">", ".", "The", "packageName", "string", "may", "be", "null", "to", "specify", "no", "preferred", "package", ".", "<", "/", "p", ">" ]

[ "public", "static", "Location", "fromBioExt", "(", "int", "start", ",", "int", "length", ",", "char", "strand", ",", "int", "totalLength", ")", "{", "int", "s", "=", "start", ";", "int", "e", "=", "s", "+", "length", ";", "if", "(", "!", "(", "strand", "==", "'", "'", "||", "strand", "==", "'", "'", "||", "strand", "==", "'", "'", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Strand must be '+', '-', or '.'\"", ")", ";", "}", "if", "(", "strand", "==", "'", "'", ")", "{", "s", "=", "s", "-", "totalLength", ";", "e", "=", "e", "-", "totalLength", ";", "}", "return", "new", "Location", "(", "s", ",", "e", ")", ";", "}" ]

[ "Create", "a", "location", "from", "MAF", "file", "coordinates", "which", "represent", "negative", "strand", "locations", "as", "the", "distance", "from", "the", "end", "of", "the", "sequence", "." ]

[ "public", "static", "String", "computeTimeAgoString", "(", "long", "ts", ",", "String", "suffix", ")", "{", "long", "now", "=", "System", ".", "currentTimeMillis", "(", ")", ";", "checkArgument", "(", "ts", "<=", "now", ",", "\"Cannot handle timestamp in the future\"", "+", "\", now: \"", "+", "now", "+", "\"/\"", "+", "new", "Date", "(", "now", ")", "+", "\", ts: \"", "+", "ts", "+", "\"/\"", "+", "new", "Date", "(", "ts", ")", ")", ";", "long", "diff", "=", "now", "-", "ts", ";", "return", "timeToReadable", "(", "diff", ",", "suffix", ")", ";", "}" ]

[ "Takes", "the", "time", "in", "milliseconds", "since", "the", "epoch", "and", "converts", "it", "into", "a", "string", "of", "x", "days", "/", "hours", "/", "minutes", "/", "seconds", "compared", "to", "the", "current", "time", "." ]

[ "private", "static", "void", "validateCreation", "(", "String", "method", ",", "SipApplicationSession", "app", ")", "{", "if", "(", "method", ".", "equals", "(", "Request", ".", "ACK", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Wrong method to create request with[\"", "+", "Request", ".", "ACK", "+", "\"]!\"", ")", ";", "}", "if", "(", "method", ".", "equals", "(", "Request", ".", "PRACK", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Wrong method to create request with[\"", "+", "Request", ".", "PRACK", "+", "\"]!\"", ")", ";", "}", "if", "(", "method", ".", "equals", "(", "Request", ".", "CANCEL", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Wrong method to create request with[\"", "+", "Request", ".", "CANCEL", "+", "\"]!\"", ")", ";", "}", "if", "(", "!", "(", "(", "MobicentsSipApplicationSession", ")", "app", ")", ".", "isValidInternal", "(", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Cant associate request with invalidaded sip session application!\"", ")", ";", "}", "}" ]

[ "Does", "basic", "check", "for", "illegal", "methods", "wrong", "state", "if", "it", "finds", "it", "throws", "exception" ]

[ "public", "boolean", "setLocalVariable", "(", "Object", "key", ",", "Object", "value", ")", "{", "boolean", "success", "=", "false", ";", "if", "(", "working", ".", "size", "(", ")", ">", "0", ")", "{", "Map", "<", "Object", ",", "Object", ">", "map", "=", "working", ".", "get", "(", "working", ".", "size", "(", ")", "-", "1", ")", ";", "map", ".", "put", "(", "key", ",", "value", ")", ";", "success", "=", "true", ";", "}", "return", "success", ";", "}" ]

[ "set", "a", "new", "local", "variable", "on", "the", "highest", "block", "hierarchy", "." ]

[ "public", "IAtom", "getPlacedHeavyAtom", "(", "IAtomContainer", "molecule", ",", "IAtom", "atomA", ",", "IAtom", "atomB", ")", "{", "List", "<", "IBond", ">", "bonds", "=", "molecule", ".", "getConnectedBondsList", "(", "atomA", ")", ";", "for", "(", "IBond", "bond", ":", "bonds", ")", "{", "IAtom", "connectedAtom", "=", "bond", ".", "getOther", "(", "atomA", ")", ";", "if", "(", "isPlacedHeavyAtom", "(", "connectedAtom", ")", "&&", "!", "connectedAtom", ".", "equals", "(", "atomB", ")", ")", "{", "return", "connectedAtom", ";", "}", "}", "return", "null", ";", "}" ]

[ "Gets", "the", "first", "placed", "Heavy", "Atom", "around", "atomA", "which", "is", "not", "atomB", "." ]

[ "public", "void", "removeExpiredTokens", "(", "CmsUser", "user", ",", "long", "now", ")", "{", "List", "<", "String", ">", "toRemove", "=", "Lists", ".", "newArrayList", "(", ")", ";", "for", "(", "Map", ".", "Entry", "<", "String", ",", "Object", ">", "entry", ":", "user", ".", "getAdditionalInfo", "(", ")", ".", "entrySet", "(", ")", ")", "{", "String", "key", "=", "entry", ".", "getKey", "(", ")", ";", "if", "(", "key", ".", "startsWith", "(", "KEY_PREFIX", ")", ")", "{", "try", "{", "long", "expiry", "=", "Long", ".", "parseLong", "(", "(", "String", ")", "entry", ".", "getValue", "(", ")", ")", ";", "if", "(", "expiry", "<", "now", ")", "{", "toRemove", ".", "add", "(", "key", ")", ";", "}", "}", "catch", "(", "NumberFormatException", "e", ")", "{", "toRemove", ".", "add", "(", "key", ")", ";", "}", "}", "}", "LOG", ".", "info", "(", "\"Removing \"", "+", "toRemove", ".", "size", "(", ")", "+", "\" expired tokens for user \"", "+", "user", ".", "getName", "(", ")", ")", ";", "for", "(", "String", "removeKey", ":", "toRemove", ")", "{", "user", ".", "getAdditionalInfo", "(", ")", ".", "remove", "(", "removeKey", ")", ";", "}", "}" ]

[ "Removes", "expired", "tokens", "from", "the", "user", "s", "additional", "infos", ".", "<p", ">" ]

[ "public", "Observable", "<", "List", "<", "PatternAnyEntityExtractor", ">", ">", "getPatternAnyEntityInfosAsync", "(", "UUID", "appId", ",", "String", "versionId", ",", "GetPatternAnyEntityInfosOptionalParameter", "getPatternAnyEntityInfosOptionalParameter", ")", "{", "return", "getPatternAnyEntityInfosWithServiceResponseAsync", "(", "appId", ",", "versionId", ",", "getPatternAnyEntityInfosOptionalParameter", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "List", "<", "PatternAnyEntityExtractor", ">", ">", ",", "List", "<", "PatternAnyEntityExtractor", ">", ">", "(", ")", "{", "@", "Override", "public", "List", "<", "PatternAnyEntityExtractor", ">", "call", "(", "ServiceResponse", "<", "List", "<", "PatternAnyEntityExtractor", ">", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Get", "information", "about", "the", "Pattern", ".", "Any", "entity", "models", "." ]

[ "public", "static", "int", "getOctalBytes", "(", "long", "value", ",", "byte", "[", "]", "buf", ",", "int", "offset", ",", "int", "length", ")", "{", "int", "idx", "=", "length", "-", "1", ";", "buf", "[", "offset", "+", "idx", "]", "=", "0", ";", "--", "idx", ";", "buf", "[", "offset", "+", "idx", "]", "=", "(", "byte", ")", "'", "'", ";", "--", "idx", ";", "if", "(", "value", "==", "0", ")", "{", "buf", "[", "offset", "+", "idx", "]", "=", "(", "byte", ")", "'", "'", ";", "--", "idx", ";", "}", "else", "{", "for", "(", "long", "val", "=", "value", ";", "idx", ">=", "0", "&&", "val", ">", "0", ";", "--", "idx", ")", "{", "buf", "[", "offset", "+", "idx", "]", "=", "(", "byte", ")", "(", "(", "byte", ")", "'", "'", "+", "(", "byte", ")", "(", "val", "&", "7", ")", ")", ";", "val", "=", "val", ">>", "3", ";", "}", "}", "for", "(", ";", "idx", ">=", "0", ";", "--", "idx", ")", "{", "buf", "[", "offset", "+", "idx", "]", "=", "(", "byte", ")", "'", "'", ";", "}", "return", "offset", "+", "length", ";", "}" ]

[ "Parse", "an", "octal", "integer", "from", "a", "header", "buffer", "." ]

[ "public", "static", "Deferred", "<", "ArrayList", "<", "byte", "[", "]", ">", ">", "resolveAllAsync", "(", "final", "TSDB", "tsdb", ",", "final", "Map", "<", "String", ",", "String", ">", "tags", ")", "{", "return", "resolveAllInternalAsync", "(", "tsdb", ",", "null", ",", "tags", ",", "false", ")", ";", "}" ]

[ "Resolves", "a", "set", "of", "tag", "strings", "to", "their", "UIDs", "asynchronously" ]

[ "public", "static", "boolean", "invertSPD", "(", "DMatrixRMaj", "mat", ",", "DMatrixRMaj", "result", ")", "{", "if", "(", "mat", ".", "numRows", "!=", "mat", ".", "numCols", ")", "throw", "new", "IllegalArgumentException", "(", "\"Must be a square matrix\"", ")", ";", "result", ".", "reshape", "(", "mat", ".", "numRows", ",", "mat", ".", "numRows", ")", ";", "if", "(", "mat", ".", "numRows", "<=", "UnrolledCholesky_DDRM", ".", "MAX", ")", "{", "// L*L' = A", "if", "(", "!", "UnrolledCholesky_DDRM", ".", "lower", "(", "mat", ",", "result", ")", ")", "return", "false", ";", "// L = inv(L)", "TriangularSolver_DDRM", ".", "invertLower", "(", "result", ".", "data", ",", "result", ".", "numCols", ")", ";", "// inv(A) = inv(L')*inv(L)", "SpecializedOps_DDRM", ".", "multLowerTranA", "(", "result", ")", ";", "}", "else", "{", "LinearSolverDense", "<", "DMatrixRMaj", ">", "solver", "=", "LinearSolverFactory_DDRM", ".", "chol", "(", "mat", ".", "numCols", ")", ";", "if", "(", "solver", ".", "modifiesA", "(", ")", ")", "mat", "=", "mat", ".", "copy", "(", ")", ";", "if", "(", "!", "solver", ".", "setA", "(", "mat", ")", ")", "return", "false", ";", "solver", ".", "invert", "(", "result", ")", ";", "}", "return", "true", ";", "}" ]

[ "Matrix", "inverse", "for", "symmetric", "positive", "definite", "matrices", ".", "For", "small", "matrices", "an", "unrolled", "cholesky", "is", "used", ".", "Otherwise", "a", "standard", "decomposition", "." ]

[ "public", "String", "detectMimeType", "(", "String", "filename", ",", "final", "InputStream", "is", ")", "throws", "GetBytesException", "{", "Callable", "<", "byte", "[", "]", ">", "getBytes", "=", "new", "Callable", "<", "byte", "[", "]", ">", "(", ")", "{", "public", "byte", "[", "]", "call", "(", ")", "throws", "IOException", "{", "return", "inputStreamToFirstBytes", "(", "is", ")", ";", "}", "}", ";", "return", "detectMimeType", "(", "filename", ",", "getBytes", ")", ";", "}" ]

[ "Determines", "the", "MIME", "type", "of", "a", "file", "with", "a", "given", "input", "stream", "." ]

[ "public", "static", "<", "T", ">", "T", "newInstance", "(", "Class", "<", "?", ">", "aClass", ",", "Class", "<", "?", ">", "parameterType", ",", "Object", "initarg", ")", "throws", "SetupException", "{", "Class", "<", "?", ">", "[", "]", "paramTypes", "=", "{", "parameterType", "}", ";", "Object", "[", "]", "initArgs", "=", "{", "initarg", "}", ";", "return", "newInstance", "(", "aClass", ",", "paramTypes", ",", "initArgs", ")", ";", "}" ]

[ "Use", "a", "constructor", "of", "the", "a", "class", "to", "create", "an", "instance" ]

[ "private", "static", "boolean", "isIcoHeader", "(", "final", "byte", "[", "]", "imageHeaderBytes", ",", "final", "int", "headerSize", ")", "{", "if", "(", "headerSize", "<", "ICO_HEADER", ".", "length", ")", "{", "return", "false", ";", "}", "return", "ImageFormatCheckerUtils", ".", "startsWithPattern", "(", "imageHeaderBytes", ",", "ICO_HEADER", ")", ";", "}" ]

[ "Checks", "if", "first", "headerSize", "bytes", "of", "imageHeaderBytes", "constitute", "a", "valid", "header", "for", "a", "ico", "image", ".", "Details", "on", "ICO", "header", "can", "be", "found", "<a", "href", "=", "https", ":", "//", "en", ".", "wikipedia", ".", "org", "/", "wiki", "/", "ICO_", "(", "file_format", ")", ">", "<", "/", "a", ">" ]

[ "public", "void", "fillText", "(", "String", "text", ",", "double", "x", ",", "double", "y", ")", "{", "this", ".", "gc", ".", "fillText", "(", "text", ",", "doc2fxX", "(", "x", ")", ",", "doc2fxY", "(", "y", ")", ")", ";", "}" ]

[ "Fills", "the", "given", "string", "of", "text", "at", "position", "x", "y", "with", "the", "current", "fill", "paint", "attribute", ".", "A", "{", "@code", "null", "}", "text", "value", "will", "be", "ignored", "." ]

[ "boolean", "isEdge", "(", "int", "x", ",", "int", "y", ")", "{", "if", "(", "edgeThreshold", "<=", "0", ")", "return", "false", ";", "double", "xx", "=", "derivXX", ".", "compute", "(", "x", ",", "y", ")", ";", "double", "xy", "=", "derivXY", ".", "compute", "(", "x", ",", "y", ")", ";", "double", "yy", "=", "derivYY", ".", "compute", "(", "x", ",", "y", ")", ";", "double", "Tr", "=", "xx", "+", "yy", ";", "double", "det", "=", "xx", "*", "yy", "-", "xy", "*", "xy", ";", "// Paper quite \"In the unlikely event that the determinant is negative, the curvatures have different signs", "// so the point is discarded as not being an extremum\"", "if", "(", "det", "<=", "0", ")", "return", "true", ";", "else", "{", "// In paper this is:", "// Tr**2/Det < (r+1)**2/r", "return", "(", "Tr", "*", "Tr", ">=", "edgeThreshold", "*", "det", ")", ";", "}", "}" ]

[ "Performs", "an", "edge", "test", "to", "remove", "false", "positives", ".", "See", "4", ".", "1", "in", "[", "1", "]", "." ]

[ "public", "void", "initialiseNonPersistent", "(", "MessageProcessor", "messageProcessor", ",", "SIMPTransactionManager", "txManager", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "tc", ",", "\"initialiseNonPersistent\"", ",", "messageProcessor", ")", ";", "//Release 1 has no Link Bundle IDs for this Neighbour", "// Cache the reference to the message processor", "_messageProcessor", "=", "messageProcessor", ";", "// Create the ObjectPool that will be used to store the ", "// subscriptionMessages. Creating with an intial length of", "// 2, but this could be made a settable parameter for performance", "_subscriptionMessagePool", "=", "new", "ObjectPool", "(", "\"SubscriptionMessages\"", ",", "NUM_MESSAGES", ")", ";", "// Create a new object to contain all the Neighbours", "_neighbours", "=", "new", "Neighbours", "(", "this", ",", "_messageProcessor", ".", "getMessagingEngineBus", "(", ")", ")", ";", "// Create a new LockManager instance", "_lockManager", "=", "new", "LockManager", "(", ")", ";", "// Assign the transaction manager", "_transactionManager", "=", "txManager", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"initialiseNonPersistent\"", ")", ";", "}" ]

[ "Called", "to", "recover", "Neighbours", "from", "the", "MessageStore", "." ]

[ "public", "static", "final", "boolean", "checkIfZero", "(", "String", "value", ",", "Class", "valueClazz", ")", "{", "boolean", "returnValue", "=", "false", ";", "if", "(", "value", "!=", "null", "&&", "NumberUtils", ".", "isNumber", "(", "value", ")", "&&", "numberTypes", ".", "get", "(", "valueClazz", ")", "!=", "null", ")", "{", "switch", "(", "numberTypes", ".", "get", "(", "valueClazz", ")", ")", "{", "case", "INTEGER", ":", "returnValue", "=", "Integer", ".", "parseInt", "(", "value", ")", "==", "(", "NumberUtils", ".", "INTEGER_ZERO", ")", ";", "break", ";", "case", "FLOAT", ":", "returnValue", "=", "Float", ".", "parseFloat", "(", "value", ")", "==", "(", "NumberUtils", ".", "FLOAT_ZERO", ")", ";", "break", ";", "case", "LONG", ":", "returnValue", "=", "Long", ".", "parseLong", "(", "value", ")", "==", "(", "NumberUtils", ".", "LONG_ZERO", ")", ";", "break", ";", "case", "BIGDECIMAL", ":", "// Note: cannot use 'equals' here - it would require both BigDecimals to have", "// the same scale.", "returnValue", "=", "(", "new", "BigDecimal", "(", "value", ")", ")", ".", "compareTo", "(", "BigDecimal", ".", "ZERO", ")", "==", "0", ";", "break", ";", "case", "BIGINTEGER", ":", "returnValue", "=", "(", "new", "BigInteger", "(", "value", ")", ")", ".", "equals", "(", "BigInteger", ".", "ZERO", ")", ";", "break", ";", "case", "SHORT", ":", "returnValue", "=", "(", "new", "Short", "(", "value", ")", ")", ".", "shortValue", "(", ")", "==", "NumberUtils", ".", "SHORT_ZERO", ".", "shortValue", "(", ")", ";", "break", ";", "}", "}", "return", "returnValue", ";", "}" ]

[ "Check", "if", "zero" ]

[ "public", "RegistryCredentialsInner", "getCredentials", "(", "String", "resourceGroupName", ",", "String", "registryName", ")", "{", "return", "getCredentialsWithServiceResponseAsync", "(", "resourceGroupName", ",", "registryName", ")", ".", "toBlocking", "(", ")", ".", "single", "(", ")", ".", "body", "(", ")", ";", "}" ]

[ "Gets", "the", "administrator", "login", "credentials", "for", "the", "specified", "container", "registry", "." ]

[ "private", "void", "readLeafTasks", "(", "Task", "parent", ",", "Integer", "id", ")", "{", "Integer", "currentID", "=", "id", ";", "Table", "table", "=", "getTable", "(", "\"A1TAB\"", ")", ";", "while", "(", "currentID", ".", "intValue", "(", ")", "!=", "0", ")", "{", "if", "(", "m_projectFile", ".", "getTaskByUniqueID", "(", "currentID", ")", "==", "null", ")", "{", "readTask", "(", "parent", ",", "currentID", ")", ";", "}", "currentID", "=", "table", ".", "find", "(", "currentID", ")", ".", "getInteger", "(", "\"NEXT_TASK_ID\"", ")", ";", "}", "}" ]

[ "Read", "the", "leaf", "tasks", "for", "an", "individual", "WBS", "node", "." ]

[ "public", "static", "int", "writeShort", "(", "byte", "[", "]", "array", ",", "int", "offset", ",", "int", "v", ")", "{", "array", "[", "offset", "+", "0", "]", "=", "(", "byte", ")", "(", "v", ">>>", "8", ")", ";", "array", "[", "offset", "+", "1", "]", "=", "(", "byte", ")", "(", "v", ">>>", "0", ")", ";", "return", "SIZE_SHORT", ";", "}" ]

[ "Write", "a", "short", "to", "the", "byte", "array", "at", "the", "given", "offset", "." ]

[ "public", "final", "static", "StringBuilder", "buildLine", "(", "StringBuilder", "sb", ",", "Object", "[", "]", "elements", ")", "{", "sb", ".", "append", "(", "'", "'", ")", ";", "String", "str", ";", "boolean", "notFirst", "=", "false", ";", "for", "(", "Object", "o", ":", "elements", ")", "{", "if", "(", "o", "!=", "null", ")", "{", "str", "=", "o", ".", "toString", "(", ")", ";", "if", "(", "str", ".", "length", "(", ")", ">", "0", ")", "{", "if", "(", "notFirst", "&&", "shouldAddSpace", "(", "str", ",", "true", ")", "&&", "shouldAddSpace", "(", "sb", ",", "false", ")", ")", "{", "sb", ".", "append", "(", "'", "'", ")", ";", "}", "else", "{", "notFirst", "=", "true", ";", "}", "sb", ".", "append", "(", "str", ")", ";", "}", "}", "}", "return", "sb", ";", "}" ]

[ "/", "*", "Build", "a", "line", "of", "code", "onto", "a", "StringBuilder", "based", "on", "Objects", ".", "Analyze", "whether", "spaces", "need", "including", "." ]

[ "public", "int", "fetchEntries", "(", "int", "tableIndex", ",", "int", "size", ",", "List", "<", "Map", ".", "Entry", "<", "K", ",", "V", ">", ">", "entries", ")", "{", "final", "long", "now", "=", "Clock", ".", "currentTimeMillis", "(", ")", ";", "final", "Segment", "<", "K", ",", "V", ">", "segment", "=", "segments", "[", "0", "]", ";", "final", "HashEntry", "<", "K", ",", "V", ">", "[", "]", "currentTable", "=", "segment", ".", "table", ";", "int", "nextTableIndex", ";", "if", "(", "tableIndex", ">=", "0", "&&", "tableIndex", "<", "segment", ".", "table", ".", "length", ")", "{", "nextTableIndex", "=", "tableIndex", ";", "}", "else", "{", "nextTableIndex", "=", "currentTable", ".", "length", "-", "1", ";", "}", "int", "counter", "=", "0", ";", "while", "(", "nextTableIndex", ">=", "0", "&&", "counter", "<", "size", ")", "{", "HashEntry", "<", "K", ",", "V", ">", "nextEntry", "=", "currentTable", "[", "nextTableIndex", "--", "]", ";", "while", "(", "nextEntry", "!=", "null", ")", "{", "if", "(", "nextEntry", ".", "key", "(", ")", "!=", "null", ")", "{", "final", "V", "value", "=", "nextEntry", ".", "value", "(", ")", ";", "if", "(", "isValidForFetching", "(", "value", ",", "now", ")", ")", "{", "K", "key", "=", "nextEntry", ".", "key", "(", ")", ";", "entries", ".", "add", "(", "new", "AbstractMap", ".", "SimpleEntry", "<", "K", ",", "V", ">", "(", "key", ",", "value", ")", ")", ";", "counter", "++", ";", "}", "}", "nextEntry", "=", "nextEntry", ".", "next", ";", "}", "}", "return", "nextTableIndex", ";", "}" ]

[ "Fetches", "entries", "from", "given", "<code", ">", "tableIndex<", "/", "code", ">", "as", "<code", ">", "size<", "/", "code", ">", "and", "puts", "them", "into", "<code", ">", "entries<", "/", "code", ">", "list", "." ]

[ "public", "static", "VersionNumber", "parseVersion", "(", "@", "Nonnull", "final", "String", "version", ")", "{", "Check", ".", "notNull", "(", "version", ",", "\"version\"", ")", ";", "VersionNumber", "result", "=", "new", "VersionNumber", "(", "new", "ArrayList", "<", "String", ">", "(", "0", ")", ",", "version", ")", ";", "final", "Matcher", "matcher", "=", "VERSIONSTRING", ".", "matcher", "(", "version", ")", ";", "if", "(", "matcher", ".", "find", "(", ")", ")", "{", "final", "List", "<", "String", ">", "groups", "=", "Arrays", ".", "asList", "(", "matcher", ".", "group", "(", "MAJOR_INDEX", ")", ".", "split", "(", "\"\\\\.\"", ")", ")", ";", "final", "String", "extension", "=", "matcher", ".", "group", "(", "EXTENSION_INDEX", ")", "==", "null", "?", "VersionNumber", ".", "EMPTY_EXTENSION", ":", "trimRight", "(", "matcher", ".", "group", "(", "EXTENSION_INDEX", ")", ")", ";", "result", "=", "new", "VersionNumber", "(", "groups", ",", "extension", ")", ";", "}", "return", "result", ";", "}" ]

[ "Interprets", "a", "string", "with", "version", "information", ".", "The", "first", "found", "group", "will", "be", "taken", "and", "processed", "." ]

[ "public", "void", "decodeBuffer", "(", "InputStream", "aStream", ",", "OutputStream", "bStream", ")", "throws", "IOException", "{", "int", "i", ";", "int", "totalBytes", "=", "0", ";", "PushbackInputStream", "ps", "=", "new", "PushbackInputStream", "(", "aStream", ")", ";", "decodeBufferPrefix", "(", "ps", ",", "bStream", ")", ";", "while", "(", "true", ")", "{", "int", "length", ";", "try", "{", "length", "=", "decodeLinePrefix", "(", "ps", ",", "bStream", ")", ";", "for", "(", "i", "=", "0", ";", "(", "i", "+", "bytesPerAtom", "(", ")", ")", "<", "length", ";", "i", "+=", "bytesPerAtom", "(", ")", ")", "{", "decodeAtom", "(", "ps", ",", "bStream", ",", "bytesPerAtom", "(", ")", ")", ";", "totalBytes", "+=", "bytesPerAtom", "(", ")", ";", "}", "if", "(", "(", "i", "+", "bytesPerAtom", "(", ")", ")", "==", "length", ")", "{", "decodeAtom", "(", "ps", ",", "bStream", ",", "bytesPerAtom", "(", ")", ")", ";", "totalBytes", "+=", "bytesPerAtom", "(", ")", ";", "}", "else", "{", "decodeAtom", "(", "ps", ",", "bStream", ",", "length", "-", "i", ")", ";", "totalBytes", "+=", "(", "length", "-", "i", ")", ";", "}", "decodeLineSuffix", "(", "ps", ",", "bStream", ")", ";", "}", "catch", "(", "CEStreamExhausted", "e", ")", "{", "break", ";", "}", "}", "decodeBufferSuffix", "(", "ps", ",", "bStream", ")", ";", "}" ]

[ "Decode", "the", "text", "from", "the", "InputStream", "and", "write", "the", "decoded", "octets", "to", "the", "OutputStream", ".", "This", "method", "runs", "until", "the", "stream", "is", "exhausted", "." ]

[ "public", "net", ".", "minidev", ".", "ovh", ".", "api", ".", "dedicated", ".", "server", ".", "OvhTask", "serviceName_backupftp_access_POST", "(", "String", "serviceName", ",", "Boolean", "cifs", ",", "Boolean", "ftp", ",", "String", "ipBlock", ",", "Boolean", "nfs", ")", "throws", "IOException", "{", "String", "qPath", "=", "\"/vps/{serviceName}/backupftp/access\"", ";", "StringBuilder", "sb", "=", "path", "(", "qPath", ",", "serviceName", ")", ";", "HashMap", "<", "String", ",", "Object", ">", "o", "=", "new", "HashMap", "<", "String", ",", "Object", ">", "(", ")", ";", "addBody", "(", "o", ",", "\"cifs\"", ",", "cifs", ")", ";", "addBody", "(", "o", ",", "\"ftp\"", ",", "ftp", ")", ";", "addBody", "(", "o", ",", "\"ipBlock\"", ",", "ipBlock", ")", ";", "addBody", "(", "o", ",", "\"nfs\"", ",", "nfs", ")", ";", "String", "resp", "=", "exec", "(", "qPath", ",", "\"POST\"", ",", "sb", ".", "toString", "(", ")", ",", "o", ")", ";", "return", "convertTo", "(", "resp", ",", "net", ".", "minidev", ".", "ovh", ".", "api", ".", "dedicated", ".", "server", ".", "OvhTask", ".", "class", ")", ";", "}" ]

[ "Create", "a", "new", "Backup", "FTP", "ACL" ]

[ "void", "setLastSeenConfig", "(", "ClusterConfiguration", "conf", ")", "throws", "IOException", "{", "String", "version", "=", "conf", ".", "getVersion", "(", ")", ".", "toSimpleString", "(", ")", ";", "File", "file", "=", "new", "File", "(", "rootDir", ",", "String", ".", "format", "(", "\"cluster_config.%s\"", ",", "version", ")", ")", ";", "FileUtils", ".", "writePropertiesToFile", "(", "conf", ".", "toProperties", "(", ")", ",", "file", ")", ";", "// Since the new config file gets created, we need to fsync the directory.", "fsyncDirectory", "(", ")", ";", "}" ]

[ "Updates", "the", "last", "seen", "configuration", "." ]

[ "public", "void", "updateGroupMembers", "(", "GroupForm", "groupForm", ",", "IPerson", "updater", ")", "{", "if", "(", "!", "canEditGroup", "(", "updater", ",", "groupForm", ".", "getKey", "(", ")", ")", ")", "{", "throw", "new", "RuntimeAuthorizationException", "(", "updater", ",", "IPermission", ".", "EDIT_GROUP_ACTIVITY", ",", "groupForm", ".", "getKey", "(", ")", ")", ";", "}", "if", "(", "log", ".", "isDebugEnabled", "(", ")", ")", "{", "log", ".", "debug", "(", "\"Updating group members for group form [\"", "+", "groupForm", ".", "toString", "(", ")", "+", "\"]\"", ")", ";", "}", "// find the current version of this group entity", "IEntityGroup", "group", "=", "GroupService", ".", "findGroup", "(", "groupForm", ".", "getKey", "(", ")", ")", ";", "// clear the current group membership list", "for", "(", "IGroupMember", "child", ":", "group", ".", "getChildren", "(", ")", ")", "{", "group", ".", "removeChild", "(", "child", ")", ";", "}", "// add all the group membership information from the group form", "// to the group", "for", "(", "JsonEntityBean", "child", ":", "groupForm", ".", "getMembers", "(", ")", ")", "{", "EntityEnum", "type", "=", "EntityEnum", ".", "getEntityEnum", "(", "child", ".", "getEntityTypeAsString", "(", ")", ")", ";", "if", "(", "type", ".", "isGroup", "(", ")", ")", "{", "IEntityGroup", "member", "=", "GroupService", ".", "findGroup", "(", "child", ".", "getId", "(", ")", ")", ";", "group", ".", "addChild", "(", "member", ")", ";", "}", "else", "{", "IGroupMember", "member", "=", "GroupService", ".", "getGroupMember", "(", "child", ".", "getId", "(", ")", ",", "type", ".", "getClazz", "(", ")", ")", ";", "group", ".", "addChild", "(", "member", ")", ";", "}", "}", "// save the group, updating both its basic information and group", "// membership", "group", ".", "updateMembers", "(", ")", ";", "}" ]

[ "Update", "the", "members", "of", "an", "existing", "group", "in", "the", "group", "store", "." ]

[ "protected", "void", "imageToOutput", "(", "double", "x", ",", "double", "y", ",", "Point2D_F64", "pt", ")", "{", "pt", ".", "x", "=", "x", "/", "scale", "-", "tranX", "/", "scale", ";", "pt", ".", "y", "=", "y", "/", "scale", "-", "tranY", "/", "scale", ";", "}" ]

[ "Converts", "a", "coordinate", "from", "pixel", "to", "the", "output", "image", "coordinates" ]

[ "@", "Override", "protected", "void", "doProcess", "(", "ITemplateContext", "context", ",", "IProcessableElementTag", "tag", ",", "IElementTagStructureHandler", "structureHandler", ")", "{", "checkPreconditions", "(", "context", ",", "tag", ",", "structureHandler", ")", ";", "final", "WebEngineContext", "webEngineContext", "=", "(", "WebEngineContext", ")", "context", ";", "final", "IModelFactory", "modelFactory", "=", "context", ".", "getModelFactory", "(", ")", ";", "final", "IModel", "model", "=", "modelFactory", ".", "createModel", "(", ")", ";", "final", "HttpServletRequest", "request", "=", "webEngineContext", ".", "getRequest", "(", ")", ";", "final", "Context", "flashMessagesContext", "=", "context", "(", "request", ")", ";", "for", "(", "Level", "level", ":", "flashMessagesContext", ".", "levels", "(", ")", ")", "{", "final", "Collection", "<", "Message", ">", "messages", "=", "flashMessagesContext", ".", "levelMessages", "(", "level", ",", "request", ")", ";", "if", "(", "!", "messages", ".", "isEmpty", "(", ")", ")", "{", "model", ".", "addModel", "(", "levelMessages", "(", "level", ",", "messages", ",", "request", ",", "modelFactory", ")", ")", ";", "}", "}", "/*\n * Instruct the engine to replace this entire element with the specified model.\n */", "structureHandler", ".", "replaceWith", "(", "model", ",", "false", ")", ";", "}" ]

[ "<pre", ">", "<div", "data", "-", "level", "=", "$", "{", "level", "}", "class", "=", "alert", "alert", "-", "$", "{", "level", "}", ">", "<c", ":", "choose", ">", "<c", ":", "when", "test", "=", "$", "{", "fn", ":", "length", "(", "messages", ")", "gt", "1", "}", ">", "<ul", ">", "<c", ":", "forEach", "var", "=", "message", "items", "=", "$", "{", "messages", "}", ">", "<li", "data", "-", "timestamp", "=", "$", "{", "message", ".", "timestamp", "}", ">", "<c", ":", "out", "value", "=", "$", "{", "message", ".", "text", "}", "escapeXml", "=", "false", "/", ">", "<", "/", "li", ">", "<", "/", "c", ":", "forEach", ">", "<", "/", "ul", ">", "<", "/", "c", ":", "when", ">", "<c", ":", "otherwise", ">", "<c", ":", "forEach", "var", "=", "message", "items", "=", "$", "{", "messages", "}", ">", "<span", "data", "-", "timestamp", "=", "$", "{", "message", ".", "timestamp", "}", ">", "<c", ":", "out", "value", "=", "$", "{", "message", ".", "text", "}", "escapeXml", "=", "false", "/", ">", "<", "/", "span", ">", "<", "/", "c", ":", "forEach", ">", "<", "/", "c", ":", "otherwise", ">", "<", "/", "c", ":", "choose", ">", "<", "/", "div", ">", "<", "/", "pre", ">" ]

[ "protected", "Message", "createMessageWithBinaryData", "(", "ConnectionContext", "context", ",", "BasicMessage", "basicMessage", ",", "InputStream", "inputStream", ")", "throws", "JMSException", "{", "return", "createMessageWithBinaryData", "(", "context", ",", "basicMessage", ",", "inputStream", ",", "null", ")", ";", "}" ]

[ "Same", "as", "{" ]

[ "private", "ObjectInfo", "selectObject", "(", "final", "int", "type", ")", "throws", "DeviceDisconnectedException", ",", "DfuException", ",", "UploadAbortedException", ",", "RemoteDfuException", ",", "UnknownResponseException", "{", "if", "(", "!", "mConnected", ")", "throw", "new", "DeviceDisconnectedException", "(", "\"Unable to read object info: device disconnected\"", ")", ";", "OP_CODE_SELECT_OBJECT", "[", "1", "]", "=", "(", "byte", ")", "type", ";", "writeOpCode", "(", "mControlPointCharacteristic", ",", "OP_CODE_SELECT_OBJECT", ")", ";", "final", "byte", "[", "]", "response", "=", "readNotificationResponse", "(", ")", ";", "final", "int", "status", "=", "getStatusCode", "(", "response", ",", "OP_CODE_SELECT_OBJECT_KEY", ")", ";", "if", "(", "status", "==", "SecureDfuError", ".", "EXTENDED_ERROR", ")", "throw", "new", "RemoteDfuExtendedErrorException", "(", "\"Selecting object failed\"", ",", "response", "[", "3", "]", ")", ";", "if", "(", "status", "!=", "DFU_STATUS_SUCCESS", ")", "throw", "new", "RemoteDfuException", "(", "\"Selecting object failed\"", ",", "status", ")", ";", "final", "ObjectInfo", "info", "=", "new", "ObjectInfo", "(", ")", ";", "info", ".", "maxSize", "=", "mControlPointCharacteristic", ".", "getIntValue", "(", "BluetoothGattCharacteristic", ".", "FORMAT_UINT32", ",", "3", ")", ";", "info", ".", "offset", "=", "mControlPointCharacteristic", ".", "getIntValue", "(", "BluetoothGattCharacteristic", ".", "FORMAT_UINT32", ",", "3", "+", "4", ")", ";", "info", ".", "CRC32", "=", "mControlPointCharacteristic", ".", "getIntValue", "(", "BluetoothGattCharacteristic", ".", "FORMAT_UINT32", ",", "3", "+", "8", ")", ";", "return", "info", ";", "}" ]

[ "Selects", "the", "current", "object", "and", "reads", "its", "metadata", ".", "The", "object", "info", "contains", "the", "max", "object", "size", "and", "the", "offset", "and", "CRC32", "of", "the", "whole", "object", "until", "now", "." ]

[ "@", "Override", "public", "void", "removeByG_P", "(", "long", "groupId", ",", "boolean", "primary", ")", "{", "for", "(", "CommerceCurrency", "commerceCurrency", ":", "findByG_P", "(", "groupId", ",", "primary", ",", "QueryUtil", ".", "ALL_POS", ",", "QueryUtil", ".", "ALL_POS", ",", "null", ")", ")", "{", "remove", "(", "commerceCurrency", ")", ";", "}", "}" ]

[ "Removes", "all", "the", "commerce", "currencies", "where", "groupId", "=", "&#63", ";", "and", "primary", "=", "&#63", ";", "from", "the", "database", "." ]

[ "protected", "void", "performSingleResourceOperation", "(", "String", "resourceName", ",", "int", "dialogAction", ")", "throws", "CmsException", "{", "// store original name to use for lock action", "String", "originalResourceName", "=", "resourceName", ";", "CmsResource", "res", "=", "getCms", "(", ")", ".", "readResource", "(", "resourceName", ",", "CmsResourceFilter", ".", "ALL", ")", ";", "if", "(", "res", ".", "isFolder", "(", ")", "&&", "!", "resourceName", ".", "endsWith", "(", "\"/\"", ")", ")", "{", "resourceName", "+=", "\"/\"", ";", "}", "org", ".", "opencms", ".", "lock", ".", "CmsLock", "lock", "=", "getCms", "(", ")", ".", "getLock", "(", "res", ")", ";", "// perform action depending on dialog uri", "switch", "(", "dialogAction", ")", "{", "case", "TYPE_LOCKCHANGE", ":", "case", "TYPE_LOCK", ":", "if", "(", "lock", ".", "isNullLock", "(", ")", ")", "{", "getCms", "(", ")", ".", "lockResource", "(", "originalResourceName", ")", ";", "}", "else", "if", "(", "!", "lock", ".", "isDirectlyOwnedInProjectBy", "(", "getCms", "(", ")", ")", ")", "{", "getCms", "(", ")", ".", "changeLock", "(", "resourceName", ")", ";", "}", "break", ";", "case", "TYPE_UNLOCK", ":", "default", ":", "if", "(", "lock", ".", "isNullLock", "(", ")", ")", "{", "break", ";", "}", "if", "(", "lock", ".", "isOwnedBy", "(", "getCms", "(", ")", ".", "getRequestContext", "(", ")", ".", "getCurrentUser", "(", ")", ")", ")", "{", "getCms", "(", ")", ".", "unlockResource", "(", "resourceName", ")", ";", "}", "}", "}" ]

[ "Performs", "the", "lock", "state", "operation", "on", "a", "single", "resource", ".", "<p", ">" ]

[ "public", "void", "addValidation", "(", "Object", "key", ",", "Validation", "validation", ")", "{", "initMapOnce", "(", ")", ";", "validations", ".", "put", "(", "key", ",", "validation", ")", ";", "// update aggregated value", "passedAll", "=", "passedAll", "&&", "validation", ".", "passed", "(", ")", ";", "}" ]

[ "Add", "a", "validation", "object", ".", "A", "key", "is", "required", "that", "can", "be", "used", "to", "retrieve", "the", "validation", "object", "." ]

[ "public", "static", "void", "appendEscapedSQLString", "(", "StringBuilder", "sb", ",", "String", "sqlString", ")", "{", "sb", ".", "append", "(", "'", "'", ")", ";", "if", "(", "sqlString", ".", "indexOf", "(", "'", "'", ")", "!=", "-", "1", ")", "{", "int", "length", "=", "sqlString", ".", "length", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "length", ";", "i", "++", ")", "{", "char", "c", "=", "sqlString", ".", "charAt", "(", "i", ")", ";", "if", "(", "c", "==", "'", "'", ")", "{", "sb", ".", "append", "(", "'", "'", ")", ";", "}", "sb", ".", "append", "(", "c", ")", ";", "}", "}", "else", "sb", ".", "append", "(", "sqlString", ")", ";", "sb", ".", "append", "(", "'", "'", ")", ";", "}" ]

[ "Appends", "an", "SQL", "string", "to", "the", "given", "StringBuilder", "including", "the", "opening", "and", "closing", "single", "quotes", ".", "Any", "single", "quotes", "internal", "to", "sqlString", "will", "be", "escaped", "." ]

[ "public", "DataSource", "<", "CloseableReference", "<", "PooledByteBuffer", ">", ">", "fetchEncodedImage", "(", "ImageRequest", "imageRequest", ",", "Object", "callerContext", ")", "{", "return", "fetchEncodedImage", "(", "imageRequest", ",", "callerContext", ",", "null", ")", ";", "}" ]

[ "Submits", "a", "request", "for", "execution", "and", "returns", "a", "DataSource", "representing", "the", "pending", "encoded", "image", "(", "s", ")", "." ]

[ "public", "static", "String", "getDetailOnlyPageName", "(", "CmsObject", "cms", ",", "CmsResource", "pageResource", ",", "String", "detailPath", ",", "String", "locale", ")", "{", "return", "getDetailOnlyPageNameWithoutLocaleCheck", "(", "detailPath", ",", "getDetailContainerLocale", "(", "cms", ",", "locale", ",", "pageResource", ")", ")", ";", "}" ]

[ "Returns", "the", "site", "/", "root", "path", "to", "the", "detail", "only", "container", "page", "for", "site", "/", "root", "path", "of", "the", "detail", "content", ".", "<p", ">" ]

[ "private", "void", "validateModality", "(", "SqlNode", "query", ")", "{", "final", "SqlModality", "modality", "=", "deduceModality", "(", "query", ")", ";", "if", "(", "query", "instanceof", "SqlSelect", ")", "{", "final", "SqlSelect", "select", "=", "(", "SqlSelect", ")", "query", ";", "validateModality", "(", "select", ",", "modality", ",", "true", ")", ";", "}", "else", "if", "(", "query", ".", "getKind", "(", ")", "==", "SqlKind", ".", "VALUES", ")", "{", "switch", "(", "modality", ")", "{", "case", "STREAM", ":", "throw", "newValidationError", "(", "query", ",", "Static", ".", "RESOURCE", ".", "cannotStreamValues", "(", ")", ")", ";", "}", "}", "else", "{", "assert", "query", ".", "isA", "(", "SqlKind", ".", "SET_QUERY", ")", ";", "final", "SqlCall", "call", "=", "(", "SqlCall", ")", "query", ";", "for", "(", "SqlNode", "operand", ":", "call", ".", "getOperandList", "(", ")", ")", "{", "if", "(", "deduceModality", "(", "operand", ")", "!=", "modality", ")", "{", "throw", "newValidationError", "(", "operand", ",", "Static", ".", "RESOURCE", ".", "streamSetOpInconsistentInputs", "(", ")", ")", ";", "}", "validateModality", "(", "operand", ")", ";", "}", "}", "}" ]

[ "Validates", "that", "a", "query", "can", "deliver", "the", "modality", "it", "promises", ".", "Only", "called", "on", "the", "top", "-", "most", "SELECT", "or", "set", "operator", "in", "the", "tree", "." ]

[ "public", "Transaction", "createWithPaymentAndClient", "(", "Payment", "payment", ",", "Client", "client", ",", "Integer", "amount", ",", "String", "currency", ")", "{", "return", "this", ".", "createWithPaymentAndClient", "(", "payment", ",", "client", ",", "amount", ",", "currency", ",", "null", ")", ";", "}" ]

[ "Executes", "a", "{" ]

[ "public", "void", "formatWrapper", "(", "final", "StringBuilder", "sb", ",", "final", "ThrowableProxy", "cause", ",", "final", "String", "suffix", ")", "{", "this", ".", "formatWrapper", "(", "sb", ",", "cause", ",", "null", ",", "PlainTextRenderer", ".", "getInstance", "(", ")", ",", "suffix", ")", ";", "}" ]

[ "Formats", "the", "specified", "Throwable", "." ]

[ "public", "PCAResult", "processIds", "(", "DBIDs", "ids", ",", "Relation", "<", "?", "extends", "NumberVector", ">", "database", ")", "{", "return", "processCovarMatrix", "(", "covarianceMatrixBuilder", ".", "processIds", "(", "ids", ",", "database", ")", ")", ";", "}" ]

[ "Run", "PCA", "on", "a", "collection", "of", "database", "IDs", "." ]

[ "private", "boolean", "isKwarg", "(", "Map", "<", "String", ",", "Object", ">", "arg", ")", "{", "Object", "kwarg", "=", "arg", ".", "get", "(", "KWARG_KEY", ")", ";", "return", "kwarg", "!=", "null", "&&", "kwarg", "instanceof", "Boolean", "&&", "(", "(", "Boolean", ")", "kwarg", ")", ";", "}" ]

[ "Checks", "whether", "an", "object", "argument", "is", "kwarg", ".", "Object", "argument", "is", "kwarg", "if", "it", "contains", "__kwarg__", "property", "set", "to", "true", "." ]

[ "public", "void", "init", "(", "Record", "record", ",", "BaseField", "fldDeleteFlag", ",", "Record", "recDetail", ")", "{", "m_fldDeleteFlag", "=", "fldDeleteFlag", ";", "m_recDetail", "=", "recDetail", ";", "super", ".", "init", "(", "record", ")", ";", "}" ]

[ "Constructor", "." ]

[ "public", "double", "get", "(", "int", "i", ",", "int", "j", ")", "{", "if", "(", "i", "<", "0", "||", "i", ">=", "N", ")", "throw", "new", "IllegalArgumentException", "(", "\"Illegal index \"", "+", "i", "+", "\" should be > 0 and < \"", "+", "N", ")", ";", "if", "(", "j", "<", "0", "||", "j", ">=", "N", ")", "throw", "new", "IllegalArgumentException", "(", "\"Illegal index \"", "+", "j", "+", "\" should be > 0 and < \"", "+", "N", ")", ";", "return", "rows", "[", "i", "]", ".", "get", "(", "j", ")", ";", "}" ]

[ "access", "a", "value", "at", "i", "j" ]

[ "public", "void", "setItemList", "(", "int", "i", ",", "ListItem", "v", ")", "{", "if", "(", "List_Type", ".", "featOkTst", "&&", "(", "(", "List_Type", ")", "jcasType", ")", ".", "casFeat_itemList", "==", "null", ")", "jcasType", ".", "jcas", ".", "throwFeatMissing", "(", "\"itemList\"", ",", "\"de.julielab.jules.types.List\"", ")", ";", "jcasType", ".", "jcas", ".", "checkArrayBounds", "(", "jcasType", ".", "ll_cas", ".", "ll_getRefValue", "(", "addr", ",", "(", "(", "List_Type", ")", "jcasType", ")", ".", "casFeatCode_itemList", ")", ",", "i", ")", ";", "jcasType", ".", "ll_cas", ".", "ll_setRefArrayValue", "(", "jcasType", ".", "ll_cas", ".", "ll_getRefValue", "(", "addr", ",", "(", "(", "List_Type", ")", "jcasType", ")", ".", "casFeatCode_itemList", ")", ",", "i", ",", "jcasType", ".", "ll_cas", ".", "ll_getFSRef", "(", "v", ")", ")", ";", "}" ]

[ "indexed", "setter", "for", "itemList", "-", "sets", "an", "indexed", "value", "-", "contains", "items", "of", "the", "level", "1", ".", "The", "items", "of", "the", "level", "1", "could", "contain", "further", "items", "of", "next", "level", "and", "so", "on", "in", "order", "to", "represent", "an", "iterative", "structure", "of", "list", "items", "." ]

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

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

[ "public", "Triple", "[", "]", "generateTriangleNeighbors", "(", "Geometry", "geometry", ")", "throws", "TopologyException", "{", "inputTriangles", "=", "geometry", ";", "CoordinateSequenceDimensionFilter", "sequenceDimensionFilter", "=", "new", "CoordinateSequenceDimensionFilter", "(", ")", ";", "geometry", ".", "apply", "(", "sequenceDimensionFilter", ")", ";", "hasZ", "=", "sequenceDimensionFilter", ".", "getDimension", "(", ")", "==", "CoordinateSequenceDimensionFilter", ".", "XYZ", ";", "Quadtree", "ptQuad", "=", "new", "Quadtree", "(", ")", ";", "// In order to compute triangle neighbors we have to set a unique id to points.", "triangleVertex", "=", "new", "Triple", "[", "geometry", ".", "getNumGeometries", "(", ")", "]", ";", "// Final size of tri vertex is not known at the moment. Give just an hint", "triVertex", "=", "new", "ArrayList", "<", "EnvelopeWithIndex", ">", "(", "triangleVertex", ".", "length", ")", ";", "// First Loop make an index of triangle vertex", "for", "(", "int", "idgeom", "=", "0", ";", "idgeom", "<", "triangleVertex", ".", "length", ";", "idgeom", "++", ")", "{", "Geometry", "geomItem", "=", "geometry", ".", "getGeometryN", "(", "idgeom", ")", ";", "if", "(", "geomItem", "instanceof", "Polygon", ")", "{", "Coordinate", "[", "]", "coords", "=", "geomItem", ".", "getCoordinates", "(", ")", ";", "if", "(", "coords", ".", "length", "!=", "4", ")", "{", "throw", "new", "TopologyException", "(", "\"Voronoi method accept only triangles\"", ")", ";", "}", "triangleVertex", "[", "idgeom", "]", "=", "new", "Triple", "(", "getOrAppendVertex", "(", "coords", "[", "0", "]", ",", "ptQuad", ")", ",", "getOrAppendVertex", "(", "coords", "[", "1", "]", ",", "ptQuad", ")", ",", "getOrAppendVertex", "(", "coords", "[", "2", "]", ",", "ptQuad", ")", ")", ";", "for", "(", "int", "triVertexIndex", ":", "triangleVertex", "[", "idgeom", "]", ".", "toArray", "(", ")", ")", "{", "triVertex", ".", "get", "(", "triVertexIndex", ")", ".", "addSharingTriangle", "(", "idgeom", ")", ";", "}", "}", "else", "{", "throw", "new", "TopologyException", "(", "\"Voronoi method accept only polygons\"", ")", ";", "}", "}", "// Second loop make an index of triangle neighbors", "ptQuad", "=", "null", ";", "triangleNeighbors", "=", "new", "Triple", "[", "geometry", ".", "getNumGeometries", "(", ")", "]", ";", "for", "(", "int", "triId", "=", "0", ";", "triId", "<", "triangleVertex", ".", "length", ";", "triId", "++", ")", "{", "Triple", "triangleIndex", "=", "triangleVertex", "[", "triId", "]", ";", "triangleNeighbors", "[", "triId", "]", "=", "new", "Triple", "(", "commonEdge", "(", "triId", ",", "triVertex", ".", "get", "(", "triangleIndex", ".", "getB", "(", ")", ")", ",", "triVertex", ".", "get", "(", "triangleIndex", ".", "getC", "(", ")", ")", ")", ",", "commonEdge", "(", "triId", ",", "triVertex", ".", "get", "(", "triangleIndex", ".", "getA", "(", ")", ")", ",", "triVertex", ".", "get", "(", "triangleIndex", ".", "getC", "(", ")", ")", ")", ",", "commonEdge", "(", "triId", ",", "triVertex", ".", "get", "(", "triangleIndex", ".", "getB", "(", ")", ")", ",", "triVertex", ".", "get", "(", "triangleIndex", ".", "getA", "(", ")", ")", ")", ")", ";", "}", "triVertex", ".", "clear", "(", ")", ";", "return", "triangleNeighbors", ";", "}" ]

[ "Given", "the", "input", "TIN", "construct", "a", "graph", "of", "triangle", "." ]

[ "@", "Override", "public", "boolean", "requeue", "(", "IQueueMessage", "<", "ID", ",", "DATA", ">", "_msg", ")", "throws", "QueueException", ".", "QueueIsFull", "{", "IQueueMessage", "<", "ID", ",", "DATA", ">", "msg", "=", "_msg", ".", "clone", "(", ")", ";", "Date", "now", "=", "new", "Date", "(", ")", ";", "msg", ".", "incNumRequeues", "(", ")", ".", "setQueueTimestamp", "(", "now", ")", ";", "putToRingBuffer", "(", "msg", ")", ";", "if", "(", "!", "isEphemeralDisabled", "(", ")", ")", "{", "ephemeralStorage", ".", "remove", "(", "msg", ".", "getId", "(", ")", ")", ";", "}", "return", "true", ";", "}" ]

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

[ "public", "InetAddress", "getInetAddress", "(", "String", "nameSpace", ",", "String", "cellName", ")", "{", "return", "getValue", "(", "nameSpace", ",", "cellName", ",", "InetAddress", ".", "class", ")", ";", "}" ]

[ "Returns", "the", "{", "@code", "InetAddress", "}", "value", "of", "the", "{", "@link", "Cell", "}", "(", "associated", "to", "{", "@code", "table", "}", ")", "whose", "name", "iscellName", "or", "null", "if", "this", "Cells", "object", "contains", "no", "cell", "whose", "name", "is", "cellName", "." ]

[ "@", "Nullable", "public", "static", "Byte", "parseByteObj", "(", "@", "Nullable", "final", "Object", "aObject", ")", "{", "return", "parseByteObj", "(", "aObject", ",", "DEFAULT_RADIX", ",", "null", ")", ";", "}" ]

[ "Parse", "the", "given", "{", "@link", "Object", "}", "as", "{", "@link", "Byte", "}", "with", "radix", "{", "@value", "#DEFAULT_RADIX", "}", "." ]

[ "protected", "final", "void", "setMeasuredDimension", "(", "View", "view", ",", "int", "width", ",", "int", "height", ")", "{", "final", "ViewProxy", "proxy", "=", "(", "ViewProxy", ")", "view", ";", "proxy", ".", "invokeSetMeasuredDimension", "(", "width", ",", "height", ")", ";", "}" ]

[ "Calls", "{" ]

[ "@", "Override", "protected", "void", "processCalendarExceptions", "(", "byte", "[", "]", "data", ",", "ProjectCalendar", "cal", ")", "{", "//", "// Handle any exceptions", "//", "int", "exceptionCount", "=", "MPPUtility", ".", "getShort", "(", "data", ",", "0", ")", ";", "if", "(", "exceptionCount", "!=", "0", ")", "{", "int", "index", ";", "int", "offset", ";", "ProjectCalendarException", "exception", ";", "long", "duration", ";", "int", "periodCount", ";", "Date", "start", ";", "for", "(", "index", "=", "0", ";", "index", "<", "exceptionCount", ";", "index", "++", ")", "{", "offset", "=", "4", "+", "(", "60", "*", "7", ")", "+", "(", "index", "*", "64", ")", ";", "Date", "fromDate", "=", "MPPUtility", ".", "getDate", "(", "data", ",", "offset", ")", ";", "Date", "toDate", "=", "MPPUtility", ".", "getDate", "(", "data", ",", "offset", "+", "2", ")", ";", "exception", "=", "cal", ".", "addCalendarException", "(", "fromDate", ",", "toDate", ")", ";", "periodCount", "=", "MPPUtility", ".", "getShort", "(", "data", ",", "offset", "+", "6", ")", ";", "if", "(", "periodCount", "!=", "0", ")", "{", "for", "(", "int", "exceptionPeriodIndex", "=", "0", ";", "exceptionPeriodIndex", "<", "periodCount", ";", "exceptionPeriodIndex", "++", ")", "{", "start", "=", "MPPUtility", ".", "getTime", "(", "data", ",", "offset", "+", "12", "+", "(", "exceptionPeriodIndex", "*", "2", ")", ")", ";", "duration", "=", "MPPUtility", ".", "getDuration", "(", "data", ",", "offset", "+", "24", "+", "(", "exceptionPeriodIndex", "*", "4", ")", ")", ";", "exception", ".", "addRange", "(", "new", "DateRange", "(", "start", ",", "new", "Date", "(", "start", ".", "getTime", "(", ")", "+", "duration", ")", ")", ")", ";", "}", "}", "}", "}", "}" ]

[ "This", "method", "extracts", "any", "exceptions", "associated", "with", "a", "calendar", "." ]

[ "public", "void", "insertNodeAt", "(", "Node", "insert", ",", "int", "index", ",", "double", "split", ")", "{", "addChild", "(", "insert", ",", "index", ",", "split", ")", ";", "notifyStateChange", "(", ")", ";", "}" ]

[ "Inserts", "a", "node", "after", "(", "right", "of", "or", "bottom", "of", ")", "a", "given", "node", "by", "splitting", "the", "inserted", "node", "with", "the", "given", "node", "." ]

[ "public", "SendAudio", "setAudio", "(", "File", "file", ")", "{", "Objects", ".", "requireNonNull", "(", "file", ",", "\"file cannot be null!\"", ")", ";", "this", ".", "audio", "=", "new", "InputFile", "(", "file", ",", "file", ".", "getName", "(", ")", ")", ";", "return", "this", ";", "}" ]

[ "Use", "this", "method", "to", "set", "the", "audio", "to", "a", "new", "file" ]

[ "@", "Pure", "public", "static", "int", "toLEInt", "(", "int", "b1", ",", "int", "b2", ",", "int", "b3", ",", "int", "b4", ")", "{", "return", "(", "(", "b4", "&", "0xFF", ")", "<<", "24", ")", "+", "(", "(", "b3", "&", "0xFF", ")", "<<", "16", ")", "+", "(", "(", "b2", "&", "0xFF", ")", "<<", "8", ")", "+", "(", "b1", "&", "0xFF", ")", ";", "}" ]

[ "Converting", "four", "bytes", "to", "a", "Little", "Endian", "integer", "." ]

[ "public", "static", "Image", "newImage", "(", "final", "String", "id", ",", "final", "IResource", "imageResource", ")", "{", "final", "Image", "image", "=", "new", "Image", "(", "id", ",", "imageResource", ")", ";", "image", ".", "setOutputMarkupId", "(", "true", ")", ";", "return", "image", ";", "}" ]

[ "Factory", "method", "for", "create", "a", "new", "{", "@link", "Image", "}", "." ]

[ "public", "static", "boolean", "inSamePackage", "(", "Symbol", "targetSymbol", ",", "VisitorState", "state", ")", "{", "JCCompilationUnit", "compilationUnit", "=", "(", "JCCompilationUnit", ")", "state", ".", "getPath", "(", ")", ".", "getCompilationUnit", "(", ")", ";", "PackageSymbol", "usePackage", "=", "compilationUnit", ".", "packge", ";", "PackageSymbol", "targetPackage", "=", "targetSymbol", ".", "packge", "(", ")", ";", "return", "targetPackage", "!=", "null", "&&", "usePackage", "!=", "null", "&&", "targetPackage", ".", "getQualifiedName", "(", ")", ".", "equals", "(", "usePackage", ".", "getQualifiedName", "(", ")", ")", ";", "}" ]

[ "Return", "true", "if", "the", "given", "symbol", "is", "defined", "in", "the", "current", "package", "." ]

[ "protected", "void", "setAddress", "(", "int", "index", ",", "long", "value", ",", "long", "scn", ")", "throws", "Exception", "{", "_addressArray", ".", "set", "(", "index", ",", "value", ",", "scn", ")", ";", "_hwmSet", "=", "Math", ".", "max", "(", "_hwmSet", ",", "scn", ")", ";", "}" ]

[ "Sets", "the", "address", "(", "long", "value", ")", "at", "the", "specified", "array", "index", "." ]

[ "private", "void", "ensureJdbcType", "(", "FieldDescriptorDef", "fieldDef", ",", "String", "checkLevel", ")", "throws", "ConstraintException", "{", "if", "(", "!", "fieldDef", ".", "hasProperty", "(", "PropertyHelper", ".", "OJB_PROPERTY_JDBC_TYPE", ")", ")", "{", "if", "(", "!", "fieldDef", ".", "hasProperty", "(", "PropertyHelper", ".", "OJB_PROPERTY_DEFAULT_JDBC_TYPE", ")", ")", "{", "throw", "new", "ConstraintException", "(", "\"No jdbc-type specified for the field \"", "+", "fieldDef", ".", "getName", "(", ")", "+", "\" in class \"", "+", "fieldDef", ".", "getOwner", "(", ")", ".", "getName", "(", ")", ")", ";", "}", "fieldDef", ".", "setProperty", "(", "PropertyHelper", ".", "OJB_PROPERTY_JDBC_TYPE", ",", "fieldDef", ".", "getProperty", "(", "PropertyHelper", ".", "OJB_PROPERTY_DEFAULT_JDBC_TYPE", ")", ")", ";", "if", "(", "!", "fieldDef", ".", "hasProperty", "(", "PropertyHelper", ".", "OJB_PROPERTY_CONVERSION", ")", "&&", "fieldDef", ".", "hasProperty", "(", "PropertyHelper", ".", "OJB_PROPERTY_DEFAULT_CONVERSION", ")", ")", "{", "fieldDef", ".", "setProperty", "(", "PropertyHelper", ".", "OJB_PROPERTY_CONVERSION", ",", "fieldDef", ".", "getProperty", "(", "PropertyHelper", ".", "OJB_PROPERTY_DEFAULT_CONVERSION", ")", ")", ";", "}", "}", "else", "{", "// we could let XDoclet check the type for field declarations but not for modifications (as we could\r", "// not specify the empty string anymore)\r", "String", "jdbcType", "=", "fieldDef", ".", "getProperty", "(", "PropertyHelper", ".", "OJB_PROPERTY_JDBC_TYPE", ")", ";", "if", "(", "!", "_jdbcTypes", ".", "containsKey", "(", "jdbcType", ")", ")", "{", "throw", "new", "ConstraintException", "(", "\"The field \"", "+", "fieldDef", ".", "getName", "(", ")", "+", "\" in class \"", "+", "fieldDef", ".", "getOwner", "(", ")", ".", "getName", "(", ")", "+", "\" specifies the invalid jdbc type \"", "+", "jdbcType", ")", ";", "}", "}", "}" ]

[ "Constraint", "that", "ensures", "that", "the", "field", "has", "a", "jdbc", "type", ".", "If", "none", "is", "specified", "then", "the", "default", "type", "is", "used", "(", "which", "has", "been", "determined", "when", "the", "field", "descriptor", "was", "added", ")", "and", "-", "if", "necessary", "-", "the", "default", "conversion", "is", "set", "." ]

[ "public", "static", "SQLiteEvent", "createInsertWithId", "(", "Long", "result", ")", "{", "return", "new", "SQLiteEvent", "(", "SqlModificationType", ".", "INSERT", ",", "null", ",", "result", ",", "null", ")", ";", "}" ]

[ "Creates", "the", "insert", "." ]

[ "public", "ItemImpl", "getItemByIdentifier", "(", "String", "identifier", ",", "boolean", "pool", ",", "boolean", "apiRead", ")", "throws", "RepositoryException", "{", "long", "start", "=", "0", ";", "if", "(", "LOG", ".", "isDebugEnabled", "(", ")", ")", "{", "start", "=", "System", ".", "currentTimeMillis", "(", ")", ";", "LOG", ".", "debug", "(", "\"getItemByIdentifier(\"", "+", "identifier", "+", "\" ) >>>>>\"", ")", ";", "}", "ItemImpl", "item", "=", "null", ";", "try", "{", "return", "item", "=", "readItem", "(", "getItemData", "(", "identifier", ")", ",", "null", ",", "pool", ",", "apiRead", ")", ";", "}", "finally", "{", "if", "(", "LOG", ".", "isDebugEnabled", "(", ")", ")", "{", "LOG", ".", "debug", "(", "\"getItemByIdentifier(\"", "+", "identifier", "+", "\") --> \"", "+", "(", "item", "!=", "null", "?", "item", ".", "getPath", "(", ")", ":", "\"null\"", ")", "+", "\" <<<<< \"", "+", "(", "(", "System", ".", "currentTimeMillis", "(", ")", "-", "start", ")", "/", "1000d", ")", "+", "\"sec\"", ")", ";", "}", "}", "}" ]

[ "For", "internal", "use", "required", "privileges", ".", "Return", "item", "by", "identifier", "in", "this", "transient", "storage", "then", "in", "workspace", "container", "." ]

[ "public", "static", "void", "appendJSON", "(", "Appendable", "a", ",", "JSONValue", "value", ")", "throws", "IOException", "{", "if", "(", "value", "==", "null", ")", "a", ".", "append", "(", "\"null\"", ")", ";", "else", "value", ".", "appendJSON", "(", "a", ")", ";", "}" ]

[ "Convenience", "method", "to", "append", "the", "JSON", "string", "for", "a", "value", "to", "an", "{", "@link", "Appendable", "}", "for", "cases", "where", "the", "value", "may", "be", "{", "@code", "null", "}", "." ]

[ "public", "void", "updateTrackerAddr", "(", "String", "trackerName", ",", "InetAddress", "addr", ")", "{", "synchronized", "(", "lockObject", ")", "{", "trackerAddress", ".", "put", "(", "trackerName", ",", "addr", ")", ";", "}", "}" ]

[ "Updates", "mapping", "between", "tracker", "names", "and", "adresses" ]

[ "protected", "Specification", "<", "ENTITY", ">", "buildSpecification", "(", "StringFilter", "filter", ",", "Function", "<", "Root", "<", "ENTITY", ">", ",", "Expression", "<", "String", ">", ">", "metaclassFunction", ")", "{", "if", "(", "filter", ".", "getEquals", "(", ")", "!=", "null", ")", "{", "return", "equalsSpecification", "(", "metaclassFunction", ",", "filter", ".", "getEquals", "(", ")", ")", ";", "}", "else", "if", "(", "filter", ".", "getIn", "(", ")", "!=", "null", ")", "{", "return", "valueIn", "(", "metaclassFunction", ",", "filter", ".", "getIn", "(", ")", ")", ";", "}", "else", "if", "(", "filter", ".", "getContains", "(", ")", "!=", "null", ")", "{", "return", "likeUpperSpecification", "(", "metaclassFunction", ",", "filter", ".", "getContains", "(", ")", ")", ";", "}", "else", "if", "(", "filter", ".", "getSpecified", "(", ")", "!=", "null", ")", "{", "return", "byFieldSpecified", "(", "metaclassFunction", ",", "filter", ".", "getSpecified", "(", ")", ")", ";", "}", "return", "null", ";", "}" ]

[ "Helper", "function", "to", "return", "a", "specification", "for", "filtering", "on", "a", "{", "@link", "String", "}", "field", "where", "equality", "containment", "and", "null", "/", "non", "-", "null", "conditions", "are", "supported", "." ]

[ "@", "Override", "public", "synchronized", "void", "beginTransaction", "(", ")", "throws", "DatabaseEngineRuntimeException", "{", "/*\n * It makes sense trying to reconnect since it's the beginning of a transaction.\n */", "try", "{", "getConnection", "(", ")", ";", "if", "(", "!", "conn", ".", "getAutoCommit", "(", ")", ")", "{", "//I.E. Manual control", "logger", ".", "debug", "(", "\"There's already one transaction active\"", ")", ";", "return", ";", "}", "conn", ".", "setAutoCommit", "(", "false", ")", ";", "}", "catch", "(", "final", "Exception", "ex", ")", "{", "throw", "new", "DatabaseEngineRuntimeException", "(", "\"Error occurred while starting transaction\"", ",", "ex", ")", ";", "}", "}" ]

[ "Starts", "a", "transaction", ".", "Doing", "this", "will", "set", "auto", "commit", "to", "false", "(", "{", "@link", "Connection#getAutoCommit", "()", "}", ")", "." ]

[ "public", "static", "DMatrixRMaj", "identity", "(", "int", "numRows", ",", "int", "numCols", ")", "{", "DMatrixRMaj", "ret", "=", "new", "DMatrixRMaj", "(", "numRows", ",", "numCols", ")", ";", "int", "small", "=", "numRows", "<", "numCols", "?", "numRows", ":", "numCols", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "small", ";", "i", "++", ")", "{", "ret", ".", "set", "(", "i", ",", "i", ",", "1.0", ")", ";", "}", "return", "ret", ";", "}" ]

[ "Creates", "a", "rectangular", "matrix", "which", "is", "zero", "except", "along", "the", "diagonals", "." ]

[ "final", "Table", "SYSTEM_SCHEMAS", "(", ")", "{", "Table", "t", "=", "sysTables", "[", "SYSTEM_SCHEMAS", "]", ";", "if", "(", "t", "==", "null", ")", "{", "t", "=", "createBlankTable", "(", "sysTableHsqlNames", "[", "SYSTEM_SCHEMAS", "]", ")", ";", "addColumn", "(", "t", ",", "\"TABLE_SCHEM\"", ",", "SQL_IDENTIFIER", ")", ";", "// not null", "addColumn", "(", "t", ",", "\"TABLE_CATALOG\"", ",", "SQL_IDENTIFIER", ")", ";", "addColumn", "(", "t", ",", "\"IS_DEFAULT\"", ",", "Type", ".", "SQL_BOOLEAN", ")", ";", "// order: TABLE_SCHEM", "// true PK, as rows never have null TABLE_SCHEM", "HsqlName", "name", "=", "HsqlNameManager", ".", "newInfoSchemaObjectName", "(", "sysTableHsqlNames", "[", "SYSTEM_SCHEMAS", "]", ".", "name", ",", "false", ",", "SchemaObject", ".", "INDEX", ")", ";", "t", ".", "createPrimaryKey", "(", "name", ",", "new", "int", "[", "]", "{", "0", "}", ",", "true", ")", ";", "return", "t", ";", "}", "PersistentStore", "store", "=", "database", ".", "persistentStoreCollection", ".", "getStore", "(", "t", ")", ";", "Iterator", "schemas", ";", "Object", "[", "]", "row", ";", "// Initialization", "schemas", "=", "database", ".", "schemaManager", ".", "fullSchemaNamesIterator", "(", ")", ";", "String", "defschema", "=", "database", ".", "schemaManager", ".", "getDefaultSchemaHsqlName", "(", ")", ".", "name", ";", "// Do it.", "while", "(", "schemas", ".", "hasNext", "(", ")", ")", "{", "row", "=", "t", ".", "getEmptyRowData", "(", ")", ";", "String", "schema", "=", "(", "String", ")", "schemas", ".", "next", "(", ")", ";", "row", "[", "0", "]", "=", "schema", ";", "row", "[", "1", "]", "=", "database", ".", "getCatalogName", "(", ")", ".", "name", ";", "row", "[", "2", "]", "=", "schema", ".", "equals", "(", "defschema", ")", "?", "Boolean", ".", "TRUE", ":", "Boolean", ".", "FALSE", ";", "t", ".", "insertSys", "(", "store", ",", "row", ")", ";", "}", "return", "t", ";", "}" ]

[ "Retrieves", "a", "<code", ">", "Table<", "/", "code", ">", "object", "describing", "the", "accessible", "schemas", "defined", "within", "this", "database", ".", "<p", ">" ]

[ "protected", "ChannelData", "createChannelData", "(", "String", "name", ",", "Class", "<", "?", ">", "factoryClass", ",", "Map", "<", "Object", ",", "Object", ">", "properties", ",", "int", "weight", ")", "{", "return", "new", "ChannelDataImpl", "(", "name", ",", "factoryClass", ",", "properties", ",", "weight", ",", "this", ")", ";", "}" ]

[ "Create", "a", "new", "ChannelData", "Object", "." ]

[ "public", "void", "addColumnEqualToField", "(", "String", "column", ",", "Object", "fieldName", ")", "{", "// PAW\r", "//SelectionCriteria c = FieldCriteria.buildEqualToCriteria(column, fieldName, getAlias());\r", "SelectionCriteria", "c", "=", "FieldCriteria", ".", "buildEqualToCriteria", "(", "column", ",", "fieldName", ",", "getUserAlias", "(", "column", ")", ")", ";", "c", ".", "setTranslateAttribute", "(", "false", ")", ";", "addSelectionCriteria", "(", "c", ")", ";", "}" ]

[ "Adds", "and", "equals", "(", "=", ")", "criteria", "for", "field", "comparison", ".", "The", "field", "name", "will", "be", "translated", "into", "the", "appropriate", "columnName", "by", "SqlStatement", ".", "The", "attribute", "will", "NOT", "be", "translated", "into", "column", "name" ]

[ "public", "static", "Collection", "<", "String", ">", "listFiles", "(", "ClassLoader", "classLoader", ",", "String", "rootPath", ")", "{", "return", "listResources", "(", "classLoader", ",", "rootPath", ",", "path", "->", "!", "StringUtils", ".", "endsWith", "(", "path", ",", "\"/\"", ")", ")", ";", "}" ]

[ "Finds", "files", "within", "a", "given", "directory", "and", "its", "subdirectories" ]

[ "protected", "void", "setTTEClassDefinition", "(", "String", "tteClass", ",", "Identification", "id", ",", "Attributes", "attr", ")", "{", "this", ".", "tteCD", "=", "ClassDefinitionImpl", ".", "toClassDefinition", "(", "tteClass", ",", "id", ",", "attr", ")", ";", "}" ]

[ "Setzt", "die", "implementierende", "Klassendefinition", "des", "Evaluator", ".", "Diese", "Methode", "wird", "durch", "die", "Klasse", "TagLibFactory", "verwendet", "." ]

[ "public", "BoxRequestsFile", ".", "DeleteFileVersion", "getDeleteVersionRequest", "(", "String", "id", ",", "String", "versionId", ")", "{", "BoxRequestsFile", ".", "DeleteFileVersion", "request", "=", "new", "BoxRequestsFile", ".", "DeleteFileVersion", "(", "versionId", ",", "getDeleteFileVersionUrl", "(", "id", ",", "versionId", ")", ",", "mSession", ")", ";", "return", "request", ";", "}" ]

[ "Gets", "a", "request", "that", "deletes", "a", "version", "of", "a", "file" ]

[ "private", "void", "updateArt", "(", "TrackMetadataUpdate", "update", ",", "AlbumArt", "art", ")", "{", "hotCache", ".", "put", "(", "DeckReference", ".", "getDeckReference", "(", "update", ".", "player", ",", "0", ")", ",", "art", ")", ";", "// Main deck", "if", "(", "update", ".", "metadata", ".", "getCueList", "(", ")", "!=", "null", ")", "{", "// Update the cache with any hot cues in this track as well", "for", "(", "CueList", ".", "Entry", "entry", ":", "update", ".", "metadata", ".", "getCueList", "(", ")", ".", "entries", ")", "{", "if", "(", "entry", ".", "hotCueNumber", "!=", "0", ")", "{", "hotCache", ".", "put", "(", "DeckReference", ".", "getDeckReference", "(", "update", ".", "player", ",", "entry", ".", "hotCueNumber", ")", ",", "art", ")", ";", "}", "}", "}", "deliverAlbumArtUpdate", "(", "update", ".", "player", ",", "art", ")", ";", "}" ]

[ "We", "have", "obtained", "album", "art", "for", "a", "device", "so", "store", "it", "and", "alert", "any", "listeners", "." ]

[ "private", "static", "void", "numericAdjustment", "(", "MethodVisitor", "mVisitor", ",", "String", "javaType", ")", "{", "adjustmentsMapper", ".", "getOrDefault", "(", "javaType", ",", "XsdAsmAttributes", "::", "doubleAdjustment", ")", ".", "accept", "(", "mVisitor", ")", ";", "}" ]

[ "Applies", "a", "cast", "to", "numeric", "types", "i", ".", "e", ".", "int", "short", "long", "to", "double", "." ]

[ "@", "Beta", "// TODO maybe load with PELoader", "public", "MSDOSLoadModule", "readMSDOSLoadModule", "(", ")", "throws", "IOException", "{", "MSDOSLoadModule", "module", "=", "new", "MSDOSLoadModule", "(", "msdos", ",", "file", ")", ";", "module", ".", "read", "(", ")", ";", "return", "module", ";", "}" ]

[ "Reads", "and", "returns", "the", "{", "@link", "MSDOSLoadModule", "}", "." ]

[ "public", "static", "ImageOutputStream", "createImageOutputStream", "(", "Object", "output", ")", "throws", "IOException", "{", "if", "(", "output", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"output == null!\"", ")", ";", "}", "Iterator", "iter", ";", "// Ensure category is present\r", "try", "{", "iter", "=", "theRegistry", ".", "getServiceProviders", "(", "ImageOutputStreamSpi", ".", "class", ",", "true", ")", ";", "}", "catch", "(", "IllegalArgumentException", "e", ")", "{", "return", "null", ";", "}", "boolean", "usecache", "=", "getUseCache", "(", ")", "&&", "hasCachePermission", "(", ")", ";", "while", "(", "iter", ".", "hasNext", "(", ")", ")", "{", "ImageOutputStreamSpi", "spi", "=", "(", "ImageOutputStreamSpi", ")", "iter", ".", "next", "(", ")", ";", "if", "(", "spi", ".", "getOutputClass", "(", ")", ".", "isInstance", "(", "output", ")", ")", "{", "try", "{", "return", "spi", ".", "createOutputStreamInstance", "(", "output", ",", "usecache", ",", "getCacheDirectory", "(", ")", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "new", "IIOException", "(", "\"Can't create cache file!\"", ",", "e", ")", ";", "}", "}", "}", "return", "null", ";", "}" ]

[ "Returns", "an", "<code", ">", "ImageOutputStream<", "/", "code", ">", "that", "will", "send", "its", "output", "to", "the", "given", "<code", ">", "Object<", "/", "code", ">", ".", "The", "set", "of", "<code", ">", "ImageOutputStreamSpi<", "/", "code", ">", "s", "registered", "with", "the", "<code", ">", "IIORegistry<", "/", "code", ">", "class", "is", "queried", "and", "the", "first", "one", "that", "is", "able", "to", "send", "output", "from", "the", "supplied", "object", "is", "used", "to", "create", "the", "returned", "<code", ">", "ImageOutputStream<", "/", "code", ">", ".", "If", "no", "suitable", "<code", ">", "ImageOutputStreamSpi<", "/", "code", ">", "exists", "<code", ">", "null<", "/", "code", ">", "is", "returned", "." ]

[ "@", "Override", "public", "void", "deserializeInstance", "(", "SerializationStreamReader", "streamReader", ",", "EntityType", "instance", ")", "throws", "SerializationException", "{", "deserialize", "(", "streamReader", ",", "instance", ")", ";", "}" ]

[ "Deserializes", "the", "content", "of", "the", "object", "from", "the", "{" ]

[ "public", "ResolvedFeatures", "getResolvedFeatures", "(", "LightweightTypeReference", "contextType", ",", "JavaVersion", "targetVersion", ")", "{", "return", "new", "ResolvedFeatures", "(", "contextType", ",", "overrideTester", ",", "targetVersion", ")", ";", "}" ]

[ "Returns", "the", "resolved", "features", "targeting", "a", "specific", "Java", "version", "in", "order", "to", "support", "new", "language", "features", "." ]

[ "static", "HandlerRegistration", "capturePageEvent", "(", "String", "name", ",", "EventHandler", "handler", ")", "{", "return", "addEventListener", "(", "Document", ".", "get", "(", ")", ",", "name", ",", "handler", ",", "true", ")", ";", "}" ]

[ "Capture", "events", "that", "occur", "anywhere", "on", "the", "page", ".", "Event", "values", "will", "be", "relative", "to", "the", "page", "(", "not", "the", "rootElement", ")", "{" ]