Datasets:

---

stojchet

/

base_prediction_dataset

like 0

[ "public", "SoundImpl", "<", "?", ">", "createSound", "(", "FileDescriptor", "fd", ",", "long", "offset", ",", "long", "length", ")", "{", "PooledSound", "sound", "=", "new", "PooledSound", "(", "pool", ".", "load", "(", "fd", ",", "offset", ",", "length", ",", "1", ")", ")", ";", "loadingSounds", ".", "put", "(", "sound", ".", "soundId", ",", "sound", ")", ";", "return", "sound", ";", "}" ]

[ "Creates", "a", "sound", "instance", "from", "the", "supplied", "file", "descriptor", "offset", "." ]

[ "@", "Override", "public", "void", "updateBeanValue", "(", ")", "{", "TableDataModel", "model", "=", "getDataModel", "(", ")", ";", "if", "(", "model", "instanceof", "ScrollableTableDataModel", ")", "{", "LOG", ".", "warn", "(", "\"UpdateBeanValue only updating the current page for ScrollableTableDataModel\"", ")", ";", "updateBeanValueCurrentPageOnly", "(", ")", ";", "}", "else", "if", "(", "model", ".", "getRowCount", "(", ")", ">", "0", ")", "{", "// Temporarily widen the pagination on the repeater to hold all rows", "// Calling setBean with a non-null value overrides the DataTableBeanProvider", "repeater", ".", "setBean", "(", "new", "RowIdList", "(", "0", ",", "model", ".", "getRowCount", "(", ")", "-", "1", ")", ")", ";", "updateBeanValueCurrentPageOnly", "(", ")", ";", "repeater", ".", "setBean", "(", "null", ")", ";", "}", "}" ]

[ "Updates", "the", "bean", "using", "the", "table", "data", "model", "s", "{" ]

[ "private", "void", "buildExternalLink", "(", "MeshData", "tile", ",", "Poly", "node", ",", "MeshData", "neighbourTile", ")", "{", "if", "(", "neighbourTile", ".", "header", ".", "bmin", "[", "0", "]", ">", "tile", ".", "header", ".", "bmin", "[", "0", "]", ")", "{", "node", ".", "neis", "[", "PolyUtils", ".", "findEdge", "(", "node", ",", "tile", ",", "neighbourTile", ".", "header", ".", "bmin", "[", "0", "]", ",", "0", ")", "]", "=", "NavMesh", ".", "DT_EXT_LINK", ";", "}", "else", "if", "(", "neighbourTile", ".", "header", ".", "bmin", "[", "0", "]", "<", "tile", ".", "header", ".", "bmin", "[", "0", "]", ")", "{", "node", ".", "neis", "[", "PolyUtils", ".", "findEdge", "(", "node", ",", "tile", ",", "tile", ".", "header", ".", "bmin", "[", "0", "]", ",", "0", ")", "]", "=", "NavMesh", ".", "DT_EXT_LINK", "|", "4", ";", "}", "else", "if", "(", "neighbourTile", ".", "header", ".", "bmin", "[", "2", "]", ">", "tile", ".", "header", ".", "bmin", "[", "2", "]", ")", "{", "node", ".", "neis", "[", "PolyUtils", ".", "findEdge", "(", "node", ",", "tile", ",", "neighbourTile", ".", "header", ".", "bmin", "[", "2", "]", ",", "2", ")", "]", "=", "NavMesh", ".", "DT_EXT_LINK", "|", "2", ";", "}", "else", "{", "node", ".", "neis", "[", "PolyUtils", ".", "findEdge", "(", "node", ",", "tile", ",", "tile", ".", "header", ".", "bmin", "[", "2", "]", ",", "2", ")", "]", "=", "NavMesh", ".", "DT_EXT_LINK", "|", "6", ";", "}", "}" ]

[ "In", "case", "of", "external", "link", "to", "other", "tiles", "we", "must", "find", "the", "direction" ]

[ "private", "File", "getFileFromConfigDirectory", "(", "String", "file", ",", "File", "def", ")", "{", "File", "f", "=", "new", "File", "(", "configDirectory", ",", "file", ")", ";", "if", "(", "configDirectory", "!=", "null", "&&", "f", ".", "exists", "(", ")", ")", "{", "return", "f", ";", "}", "if", "(", "def", "!=", "null", "&&", "def", ".", "exists", "(", ")", ")", "{", "return", "def", ";", "}", "return", "null", ";", "}" ]

[ "/", "*", "Get", "the", "file", "from", "configDrectory", "if", "it", "exists", ";", "otherwise", "return", "def", "only", "if", "it", "exists", "or", "null", "if", "not" ]

[ "public", "static", "RedirectionAction", "buildRedirectUrlAction", "(", "final", "WebContext", "context", ",", "final", "String", "location", ")", "{", "if", "(", "ContextHelper", ".", "isPost", "(", "context", ")", "&&", "useModernHttpCodes", ")", "{", "return", "new", "SeeOtherAction", "(", "location", ")", ";", "}", "else", "{", "return", "new", "FoundAction", "(", "location", ")", ";", "}", "}" ]

[ "Build", "the", "appropriate", "redirection", "action", "for", "a", "location", "." ]

[ "@", "Override", "public", "int", "compare", "(", "final", "Row", "row0", ",", "final", "Row", "row1", ")", "{", "int", "result", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "orderbys", ".", "size", "(", ")", ";", "i", "++", ")", "{", "final", "OrderColumn", "oc", "=", "orderbys", ".", "get", "(", "i", ")", ";", "// null indicates \"detail\" record which is what the parser assigns\r", "// to <column> 's setup outside of <record> elements\r", "final", "String", "mdkey0", "=", "row0", ".", "getMdkey", "(", ")", "==", "null", "?", "FPConstants", ".", "DETAIL_ID", ":", "row0", ".", "getMdkey", "(", ")", ";", "final", "String", "mdkey1", "=", "row1", ".", "getMdkey", "(", ")", "==", "null", "?", "FPConstants", ".", "DETAIL_ID", ":", "row1", ".", "getMdkey", "(", ")", ";", "// shift all non detail records to the bottom of the DataSet\r", "if", "(", "!", "mdkey0", ".", "equals", "(", "FPConstants", ".", "DETAIL_ID", ")", "&&", "!", "mdkey1", ".", "equals", "(", "FPConstants", ".", "DETAIL_ID", ")", ")", "{", "// keep headers / trailers in the same order at the bottom of\r", "// the DataSet\r", "return", "0", ";", "}", "else", "if", "(", "!", "mdkey0", ".", "equals", "(", "FPConstants", ".", "DETAIL_ID", ")", "||", "!", "mdkey1", ".", "equals", "(", "FPConstants", ".", "DETAIL_ID", ")", ")", "{", "return", "!", "mdkey0", ".", "equals", "(", "FPConstants", ".", "DETAIL_ID", ")", "?", "1", ":", "0", ";", "}", "result", "=", "compareCol", "(", "row0", ",", "row1", ",", "oc", ")", ";", "// if it is = 0 then the primary sort is done, and it can start the\r", "// secondary sorts\r", "if", "(", "result", "!=", "0", ")", "{", "break", ";", "}", "}", "return", "result", ";", "}" ]

[ "overridden", "from", "the", "Comparator", "class", "." ]

[ "@", "Override", "public", "void", "serializeInstance", "(", "SerializationStreamWriter", "streamWriter", ",", "OWLObjectProperty", "instance", ")", "throws", "SerializationException", "{", "serialize", "(", "streamWriter", ",", "instance", ")", ";", "}" ]

[ "Serializes", "the", "content", "of", "the", "object", "into", "the", "{" ]

[ "public", "static", "InputDialog", "showInputDialog", "(", "Stage", "stage", ",", "String", "title", ",", "String", "fieldTitle", ",", "InputDialogListener", "listener", ")", "{", "InputDialog", "dialog", "=", "new", "InputDialog", "(", "title", ",", "fieldTitle", ",", "true", ",", "null", ",", "listener", ")", ";", "stage", ".", "addActor", "(", "dialog", ".", "fadeIn", "(", ")", ")", ";", "return", "dialog", ";", "}" ]

[ "Dialog", "with", "text", "and", "text", "field", "for", "user", "input", ".", "Cannot", "be", "canceled", "." ]

[ "public", "static", "void", "recursiveDelete", "(", "Path", "directory", ")", "throws", "IOException", "{", "try", "{", "Files", ".", "walkFileTree", "(", "directory", ",", "new", "SimpleFileVisitor", "<", "Path", ">", "(", ")", "{", "@", "Override", "public", "FileVisitResult", "visitFile", "(", "Path", "file", ",", "BasicFileAttributes", "attrs", ")", "throws", "java", ".", "io", ".", "IOException", "{", "try", "{", "Files", ".", "delete", "(", "file", ")", ";", "}", "catch", "(", "NoSuchFileException", "ignore", ")", "{", "}", "return", "FileVisitResult", ".", "CONTINUE", ";", "}", "@", "Override", "public", "FileVisitResult", "postVisitDirectory", "(", "Path", "dir", ",", "java", ".", "io", ".", "IOException", "exc", ")", "throws", "java", ".", "io", ".", "IOException", "{", "try", "{", "Files", ".", "delete", "(", "dir", ")", ";", "}", "catch", "(", "NoSuchFileException", "ignore", ")", "{", "}", "return", "FileVisitResult", ".", "CONTINUE", ";", "}", "}", ")", ";", "}", "catch", "(", "NoSuchFileException", "ignore", ")", "{", "}", "}" ]

[ "Deletes", "a", "directory", "recursively", "with", "all", "its", "contents", ".", "Will", "ignore", "files", "and", "directories", "if", "they", "are", "disappear", "during", "the", "oprtation", "." ]

[ "@", "Override", "public", "SerIterable", "createIterable", "(", "final", "String", "metaTypeDescription", ",", "final", "JodaBeanSer", "settings", ",", "final", "Map", "<", "String", ",", "Class", "<", "?", ">", ">", "knownTypes", ")", "{", "if", "(", "metaTypeDescription", ".", "equals", "(", "\"Grid\"", ")", ")", "{", "return", "grid", "(", "Object", ".", "class", ",", "EMPTY_VALUE_TYPES", ")", ";", "}", "return", "super", ".", "createIterable", "(", "metaTypeDescription", ",", "settings", ",", "knownTypes", ")", ";", "}" ]

[ "Creates", "an", "iterator", "wrapper", "for", "a", "meta", "-", "property", "value", "." ]

[ "public", "Object", "unmarshalRootElement", "(", "Reader", "inStream", ",", "BaseXmlTrxMessageIn", "soapTrxMessage", ")", "throws", "Exception", "{", "String", "xml", "=", "Utility", ".", "transferURLStream", "(", "null", ",", "null", ",", "inStream", ",", "null", ")", ";", "soapTrxMessage", ".", "getMessage", "(", ")", ".", "setXML", "(", "xml", ")", ";", "return", "xml", ";", "}" ]

[ "Create", "the", "root", "element", "for", "this", "message", ".", "You", "must", "override", "this", "." ]

[ "protected", "Dialog", "createNewTCAPDialog", "(", "SccpAddress", "origAddress", ",", "SccpAddress", "destAddress", ",", "Long", "localTrId", ")", "throws", "CAPException", "{", "try", "{", "return", "this", ".", "capProviderImpl", ".", "getTCAPProvider", "(", ")", ".", "getNewDialog", "(", "origAddress", ",", "destAddress", ",", "localTrId", ")", ";", "}", "catch", "(", "TCAPException", "e", ")", "{", "throw", "new", "CAPException", "(", "e", ".", "getMessage", "(", ")", ",", "e", ")", ";", "}", "}" ]

[ "Creating", "new", "outgoing", "TCAP", "Dialog", ".", "Used", "when", "creating", "a", "new", "outgoing", "CAP", "Dialog" ]

[ "public", "MsgChecker", "replaceCallback", "(", "BasicCheckRule", "type", ",", "ValidationInvalidCallback", "cb", ")", "{", "this", ".", "callbackMap", ".", "put", "(", "type", ".", "name", "(", ")", ",", "cb", ")", ";", "return", "this", ";", "}" ]

[ "Replace", "callback", "msg", "checker", "." ]

[ "public", "static", "boolean", "parseBool", "(", "@", "Nullable", "final", "Object", "aObject", ",", "final", "boolean", "bDefault", ")", "{", "if", "(", "aObject", "instanceof", "Boolean", ")", "return", "(", "(", "Boolean", ")", "aObject", ")", ".", "booleanValue", "(", ")", ";", "if", "(", "aObject", "instanceof", "String", ")", "return", "parseBool", "(", "(", "String", ")", "aObject", ")", ";", "return", "bDefault", ";", "}" ]

[ "Try", "to", "interpret", "the", "passed", "object", "as", "boolean", ".", "This", "works", "only", "if", "the", "passed", "object", "is", "either", "a", "{", "@link", "String", "}", "or", "a", "{", "@link", "Boolean", "}", "." ]

[ "private", "void", "outputIndexTerm", "(", "final", "IndexTerm", "term", ",", "final", "XMLSerializer", "serializer", ")", "throws", "SAXException", "{", "List", "<", "IndexTermTarget", ">", "targets", "=", "term", ".", "getTargetList", "(", ")", ";", "final", "List", "<", "IndexTerm", ">", "subTerms", "=", "term", ".", "getSubTerms", "(", ")", ";", "int", "targetNum", "=", "targets", ".", "size", "(", ")", ";", "final", "int", "subTermNum", "=", "subTerms", ".", "size", "(", ")", ";", "serializer", ".", "writeStartElement", "(", "\"li\"", ")", ";", "serializer", ".", "writeStartElement", "(", "\"object\"", ")", ";", "serializer", ".", "writeAttribute", "(", "\"type\"", ",", "\"text/sitemap\"", ")", ";", "serializer", ".", "writeStartElement", "(", "\"param\"", ")", ";", "serializer", ".", "writeAttribute", "(", "\"name\"", ",", "\"Name\"", ")", ";", "serializer", ".", "writeAttribute", "(", "\"value\"", ",", "term", ".", "getTermFullName", "(", ")", ")", ";", "serializer", ".", "writeEndElement", "(", ")", ";", "// param", "//if term doesn't has target to link to, it won't appear in the index tab", "//we need to create links for such terms", "if", "(", "targets", ".", "isEmpty", "(", ")", ")", "{", "findTargets", "(", "term", ")", ";", "targets", "=", "term", ".", "getTargetList", "(", ")", ";", "targetNum", "=", "targets", ".", "size", "(", ")", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "targetNum", ";", "i", "++", ")", "{", "final", "IndexTermTarget", "target", "=", "targets", ".", "get", "(", "i", ")", ";", "serializer", ".", "writeStartElement", "(", "\"param\"", ")", ";", "serializer", ".", "writeAttribute", "(", "\"name\"", ",", "\"Name\"", ")", ";", "serializer", ".", "writeAttribute", "(", "\"value\"", ",", "target", ".", "getTargetName", "(", ")", ")", ";", "serializer", ".", "writeEndElement", "(", ")", ";", "// param", "serializer", ".", "writeStartElement", "(", "\"param\"", ")", ";", "serializer", ".", "writeAttribute", "(", "\"name\"", ",", "\"Local\"", ")", ";", "serializer", ".", "writeAttribute", "(", "\"value\"", ",", "target", ".", "getTargetURI", "(", ")", ")", ";", "serializer", ".", "writeEndElement", "(", ")", ";", "// param", "}", "serializer", ".", "writeEndElement", "(", ")", ";", "// object", "if", "(", "subTermNum", ">", "0", ")", "{", "serializer", ".", "writeStartElement", "(", "\"ul\"", ")", ";", "for", "(", "final", "IndexTerm", "subTerm", ":", "subTerms", ")", "{", "outputIndexTerm", "(", "subTerm", ",", "serializer", ")", ";", "}", "serializer", ".", "writeEndElement", "(", ")", ";", "// ul", "}", "serializer", ".", "writeEndElement", "(", ")", ";", "// li", "}" ]

[ "Output", "the", "given", "indexterm", "into", "the", "XML", "writer", "." ]

[ "JavaFileObject", "genCode", "(", "Env", "<", "AttrContext", ">", "env", ",", "JCClassDecl", "cdef", ")", "throws", "IOException", "{", "try", "{", "if", "(", "gen", ".", "genClass", "(", "env", ",", "cdef", ")", "&&", "(", "errorCount", "(", ")", "==", "0", ")", ")", "return", "writer", ".", "writeClass", "(", "cdef", ".", "sym", ")", ";", "}", "catch", "(", "ClassWriter", ".", "PoolOverflow", "ex", ")", "{", "log", ".", "error", "(", "cdef", ".", "pos", "(", ")", ",", "\"limit.pool\"", ")", ";", "}", "catch", "(", "ClassWriter", ".", "StringOverflow", "ex", ")", "{", "log", ".", "error", "(", "cdef", ".", "pos", "(", ")", ",", "\"limit.string.overflow\"", ",", "ex", ".", "value", ".", "substring", "(", "0", ",", "20", ")", ")", ";", "}", "catch", "(", "CompletionFailure", "ex", ")", "{", "chk", ".", "completionError", "(", "cdef", ".", "pos", "(", ")", ",", "ex", ")", ";", "}", "return", "null", ";", "}" ]

[ "Generate", "code", "and", "emit", "a", "class", "file", "for", "a", "given", "class" ]

[ "static", "void", "onPersist", "(", "final", "EntityManager", "em", ",", "final", "User", "user", ")", "{", "logger", ".", "info", "(", "\"\"", ")", ";", "logger", ".", "info", "(", "\"\"", ")", ";", "logger", ".", "info", "(", "\"#######################Persisting##########################################\"", ")", ";", "logger", ".", "info", "(", "\"\"", ")", ";", "logger", ".", "info", "(", "user", ".", "toString", "(", ")", ")", ";", "persist", "(", "user", ",", "em", ")", ";", "logger", ".", "info", "(", "\"\"", ")", ";", "System", ".", "out", ".", "println", "(", "\"#######################Persisting##########################################\"", ")", ";", "logger", ".", "info", "(", "\"\"", ")", ";", "logger", ".", "info", "(", "\"\"", ")", ";", "}" ]

[ "On", "persist", "user", "." ]

[ "boolean", "checkAccessTopicFromJsTopicControl", "(", "UserContext", "ctx", ",", "String", "topic", ")", "throws", "IllegalAccessException", "{", "logger", ".", "debug", "(", "\"Looking for accessController for topic '{}' from JsTopicControl annotation\"", ",", "topic", ")", ";", "Iterable", "<", "JsTopicAccessController", ">", "accessControls", "=", "topicAccessController", ".", "select", "(", "new", "JsTopicCtrlAnnotationLiteral", "(", "topic", ")", ")", ";", "return", "checkAccessTopicFromControllers", "(", "ctx", ",", "topic", ",", "accessControls", ")", ";", "}" ]

[ "Check", "if", "specific", "access", "control", "is", "allowed" ]

[ "public", "void", "deleteDataLakeStoreAccount", "(", "String", "resourceGroupName", ",", "String", "accountName", ",", "String", "dataLakeStoreAccountName", ")", "{", "deleteDataLakeStoreAccountWithServiceResponseAsync", "(", "resourceGroupName", ",", "accountName", ",", "dataLakeStoreAccountName", ")", ".", "toBlocking", "(", ")", ".", "single", "(", ")", ".", "body", "(", ")", ";", "}" ]

[ "Updates", "the", "Data", "Lake", "Analytics", "account", "specified", "to", "remove", "the", "specified", "Data", "Lake", "Store", "account", "." ]

[ "public", "static", "int", "requiredIntAttribute", "(", "final", "XMLStreamReader", "reader", ",", "final", "String", "localName", ")", "throws", "XMLStreamException", "{", "return", "requiredIntAttribute", "(", "reader", ",", "null", ",", "localName", ")", ";", "}" ]

[ "Returns", "the", "value", "of", "an", "attribute", "as", "a", "int", ".", "If", "the", "attribute", "is", "empty", "this", "method", "throws", "an", "exception", "." ]

[ "public", "void", "readToken", "(", "String", "parentFieldName", ",", "JsonToken", "expectedToken", ")", "throws", "IOException", "{", "JsonToken", "currentToken", "=", "jsonParser", ".", "nextToken", "(", ")", ";", "if", "(", "currentToken", "!=", "expectedToken", ")", "{", "throw", "new", "IOException", "(", "\"Expected a \"", "+", "expectedToken", ".", "toString", "(", ")", "+", "\" token when reading the value of the field: \"", "+", "parentFieldName", "+", "\" but found a \"", "+", "currentToken", ".", "toString", "(", ")", "+", "\" token\"", ")", ";", "}", "}" ]

[ "This", "is", "a", "helper", "method", "that", "reads", "a", "JSON", "token", "using", "a", "JsonParser", "instance", "and", "throws", "an", "exception", "if", "the", "next", "token", "is", "not", "the", "same", "as", "the", "token", "we", "expect", "." ]

[ "private", "void", "setUserGroupNames", "(", "String", "userName", ",", "String", "[", "]", "groupNames", ")", "{", "if", "(", "userName", "==", "null", "||", "userName", ".", "length", "(", ")", "==", "0", "||", "groupNames", "==", "null", "||", "groupNames", ".", "length", "==", "0", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Parameters should not be null or an empty string/array\"", ")", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "groupNames", ".", "length", ";", "i", "++", ")", "{", "if", "(", "groupNames", "[", "i", "]", "==", "null", "||", "groupNames", "[", "i", "]", ".", "length", "(", ")", "==", "0", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"A null group name at index \"", "+", "i", ")", ";", "}", "}", "this", ".", "userName", "=", "userName", ";", "this", ".", "groupNames", "=", "groupNames", ";", "}" ]

[ "/", "*", "Set", "this", "object", "s", "user", "name", "and", "group", "names" ]

[ "public", "static", "boolean", "lossyEquals", "(", "final", "Locale", "locale", ",", "final", "String", "source", ",", "final", "String", "target", ")", "{", "return", "withinLocale", "(", "new", "Callable", "<", "Boolean", ">", "(", ")", "{", "@", "Override", "public", "Boolean", "call", "(", ")", "throws", "Exception", "{", "return", "lossyEquals", "(", "source", ",", "target", ")", ";", "}", "}", ",", "locale", ")", ";", "}" ]

[ "<p", ">", "Same", "as", "{", "@link", "#lossyEquals", "(", "String", "String", ")", "}", "for", "the", "specified", "locale", ".", "<", "/", "p", ">" ]

[ "private", "Path", "getOrGenerateSchemaFile", "(", "Schema", "schema", ")", "throws", "IOException", "{", "Preconditions", ".", "checkNotNull", "(", "schema", ",", "\"Avro Schema should not be null\"", ")", ";", "String", "hashedSchema", "=", "Hashing", ".", "sha256", "(", ")", ".", "hashString", "(", "schema", ".", "toString", "(", ")", ",", "StandardCharsets", ".", "UTF_8", ")", ".", "toString", "(", ")", ";", "if", "(", "!", "this", ".", "schemaPaths", ".", "containsKey", "(", "hashedSchema", ")", ")", "{", "Path", "schemaFilePath", "=", "new", "Path", "(", "this", ".", "schemaDir", ",", "String", ".", "valueOf", "(", "System", ".", "currentTimeMillis", "(", ")", "+", "\".avsc\"", ")", ")", ";", "AvroUtils", ".", "writeSchemaToFile", "(", "schema", ",", "schemaFilePath", ",", "fs", ",", "true", ")", ";", "this", ".", "schemaPaths", ".", "put", "(", "hashedSchema", ",", "schemaFilePath", ")", ";", "}", "return", "this", ".", "schemaPaths", ".", "get", "(", "hashedSchema", ")", ";", "}" ]

[ "If", "url", "for", "schema", "already", "exists", "return", "the", "url", ".", "If", "not", "create", "a", "new", "temporary", "schema", "file", "and", "return", "a", "the", "url", "." ]

[ "public", "AccessUriInner", "grantAccess", "(", "String", "resourceGroupName", ",", "String", "diskName", ",", "GrantAccessData", "grantAccessData", ")", "{", "return", "grantAccessWithServiceResponseAsync", "(", "resourceGroupName", ",", "diskName", ",", "grantAccessData", ")", ".", "toBlocking", "(", ")", ".", "last", "(", ")", ".", "body", "(", ")", ";", "}" ]

[ "Grants", "access", "to", "a", "disk", "." ]

[ "public", "String", "putValue", "(", "String", "name", ",", "String", "value", ")", "{", "return", "(", "String", ")", "put", "(", "new", "Name", "(", "name", ")", ",", "value", ")", ";", "}" ]

[ "Associates", "the", "specified", "value", "with", "the", "specified", "attribute", "name", "specified", "as", "a", "String", ".", "The", "attributes", "name", "is", "case", "-", "insensitive", ".", "If", "the", "Map", "previously", "contained", "a", "mapping", "for", "the", "attribute", "name", "the", "old", "value", "is", "replaced", ".", "<p", ">", "This", "method", "is", "defined", "as", ":", "<pre", ">", "return", "(", "String", ")", "put", "(", "new", "Attributes", ".", "Name", "(", "name", ")", "value", ")", ";", "<", "/", "pre", ">" ]

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

[ "Gets", "the", "detailed", "information", "for", "a", "given", "run", "." ]

[ "private", "boolean", "isOfDefinitionType", "(", "AnnotatedType", "annotatedType", ",", "Class", "<", "?", "extends", "Annotation", ">", "definitionType", ")", "{", "Annotation", "definition", "=", "annotatedType", ".", "getByMetaAnnotation", "(", "definitionType", ")", ";", "if", "(", "definition", "!=", "null", ")", "{", "return", "true", ";", "}", "for", "(", "Class", "<", "?", ">", "superType", ":", "annotatedType", ".", "getAnnotatedElement", "(", ")", ".", "getInterfaces", "(", ")", ")", "{", "if", "(", "isOfDefinitionType", "(", "new", "AnnotatedType", "(", "superType", ")", ",", "definitionType", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Determines", "if", "an", "{", "@link", "AnnotatedType", "}", "represents", "a", "specific", "type", "identified", "by", "a", "meta", "annotation", "." ]

[ "public", "static", "SearchFilter", "newLdaptiveSearchFilter", "(", "final", "String", "filterQuery", ",", "final", "String", "paramName", ",", "final", "List", "<", "String", ">", "params", ")", "{", "val", "filter", "=", "new", "SearchFilter", "(", ")", ";", "filter", ".", "setFilter", "(", "filterQuery", ")", ";", "if", "(", "params", "!=", "null", ")", "{", "IntStream", ".", "range", "(", "0", ",", "params", ".", "size", "(", ")", ")", ".", "forEach", "(", "i", "->", "{", "if", "(", "filter", ".", "getFilter", "(", ")", ".", "contains", "(", "\"{\"", "+", "i", "+", "'", "'", ")", ")", "{", "filter", ".", "setParameter", "(", "i", ",", "params", ".", "get", "(", "i", ")", ")", ";", "}", "else", "{", "filter", ".", "setParameter", "(", "paramName", ",", "params", ".", "get", "(", "i", ")", ")", ";", "}", "}", ")", ";", "}", "LOGGER", ".", "debug", "(", "\"Constructed LDAP search filter [{}]\"", ",", "filter", ".", "format", "(", ")", ")", ";", "return", "filter", ";", "}" ]

[ "Constructs", "a", "new", "search", "filter", "using", "{", "@link", "SearchExecutor#getSearchFilter", "()", "}", "as", "a", "template", "and", "the", "username", "as", "a", "parameter", "." ]

[ "public", "ArrayList", "<", "SAXRecord", ">", "getSimpleMotifs", "(", "int", "num", ")", "{", "ArrayList", "<", "SAXRecord", ">", "res", "=", "new", "ArrayList", "<", "SAXRecord", ">", "(", "num", ")", ";", "DoublyLinkedSortedList", "<", "Entry", "<", "String", ",", "SAXRecord", ">", ">", "list", "=", "new", "DoublyLinkedSortedList", "<", "Entry", "<", "String", ",", "SAXRecord", ">", ">", "(", "num", ",", "new", "Comparator", "<", "Entry", "<", "String", ",", "SAXRecord", ">", ">", "(", ")", "{", "@", "Override", "public", "int", "compare", "(", "Entry", "<", "String", ",", "SAXRecord", ">", "o1", ",", "Entry", "<", "String", ",", "SAXRecord", ">", "o2", ")", "{", "int", "f1", "=", "o1", ".", "getValue", "(", ")", ".", "getIndexes", "(", ")", ".", "size", "(", ")", ";", "int", "f2", "=", "o2", ".", "getValue", "(", ")", ".", "getIndexes", "(", ")", ".", "size", "(", ")", ";", "return", "Integer", ".", "compare", "(", "f1", ",", "f2", ")", ";", "}", "}", ")", ";", "for", "(", "Entry", "<", "String", ",", "SAXRecord", ">", "e", ":", "this", ".", "records", ".", "entrySet", "(", ")", ")", "{", "list", ".", "addElement", "(", "e", ")", ";", "}", "Iterator", "<", "Entry", "<", "String", ",", "SAXRecord", ">", ">", "i", "=", "list", ".", "iterator", "(", ")", ";", "while", "(", "i", ".", "hasNext", "(", ")", ")", "{", "res", ".", "add", "(", "i", ".", "next", "(", ")", ".", "getValue", "(", ")", ")", ";", "}", "return", "res", ";", "}" ]

[ "Get", "motifs", "." ]

[ "public", "static", "void", "shredInputStream", "(", "final", "INodeWriteTrx", "wtx", ",", "final", "InputStream", "value", ",", "final", "EShredderInsert", "child", ")", "{", "final", "XMLInputFactory", "factory", "=", "XMLInputFactory", ".", "newInstance", "(", ")", ";", "factory", ".", "setProperty", "(", "XMLInputFactory", ".", "SUPPORT_DTD", ",", "false", ")", ";", "XMLEventReader", "parser", ";", "try", "{", "parser", "=", "factory", ".", "createXMLEventReader", "(", "value", ")", ";", "}", "catch", "(", "final", "XMLStreamException", "xmlse", ")", "{", "throw", "new", "WebApplicationException", "(", "xmlse", ")", ";", "}", "try", "{", "final", "XMLShredder", "shredder", "=", "new", "XMLShredder", "(", "wtx", ",", "parser", ",", "child", ")", ";", "shredder", ".", "call", "(", ")", ";", "}", "catch", "(", "final", "Exception", "exce", ")", "{", "throw", "new", "WebApplicationException", "(", "exce", ")", ";", "}", "}" ]

[ "Shreds", "a", "given", "InputStream" ]

[ "@", "CrossOrigin", "(", "allowedHeaders", "=", "{", "\"*\"", "}", ",", "origins", "=", "{", "\"*\"", "}", ")", "@", "RequestMapping", "(", "value", "=", "{", "\"{identifier}/manifest\"", ",", "\"{identifier}\"", "}", ",", "method", "=", "RequestMethod", ".", "GET", ",", "produces", "=", "\"application/json\"", ")", "@", "ResponseBody", "public", "Manifest", "getManifest", "(", "@", "PathVariable", "String", "identifier", ",", "HttpServletRequest", "request", ")", "throws", "NotFoundException", ",", "InvalidDataException", "{", "HttpLoggingUtilities", ".", "addRequestClientInfoToMDC", "(", "request", ")", ";", "MDC", ".", "put", "(", "\"manifestId\"", ",", "identifier", ")", ";", "try", "{", "Manifest", "manifest", "=", "presentationService", ".", "getManifest", "(", "identifier", ")", ";", "LOGGER", ".", "info", "(", "\"Serving manifest for {}\"", ",", "identifier", ")", ";", "return", "manifest", ";", "}", "catch", "(", "NotFoundException", "e", ")", "{", "LOGGER", ".", "info", "(", "\"Did not find manifest for {}\"", ",", "identifier", ")", ";", "throw", "e", ";", "}", "catch", "(", "InvalidDataException", "e", ")", "{", "LOGGER", ".", "error", "(", "\"Bad data for {}\"", ",", "identifier", ")", ";", "throw", "e", ";", "}", "finally", "{", "MDC", ".", "clear", "(", ")", ";", "}", "}" ]

[ "The", "manifest", "response", "contains", "sufficient", "information", "for", "the", "client", "to", "initialize", "itself", "and", "begin", "to", "display", "something", "quickly", "to", "the", "user", ".", "The", "manifest", "resource", "represents", "a", "single", "object", "and", "any", "intellectual", "work", "or", "works", "embodied", "within", "that", "object", ".", "In", "particular", "it", "includes", "the", "descriptive", "rights", "and", "linking", "information", "for", "the", "object", ".", "It", "then", "embeds", "the", "sequence", "(", "s", ")", "of", "canvases", "that", "should", "be", "rendered", "to", "the", "user", "." ]

[ "public", "void", "sendMessageTo", "(", "VertexKey", "target", ",", "Message", "m", ")", "{", "outValue", ".", "f0", "=", "target", ";", "outValue", ".", "f1", "=", "m", ";", "out", ".", "collect", "(", "outValue", ")", ";", "}" ]

[ "Sends", "the", "given", "message", "to", "the", "vertex", "identified", "by", "the", "given", "key", ".", "If", "the", "target", "vertex", "does", "not", "exist", "the", "next", "superstep", "will", "cause", "an", "exception", "due", "to", "a", "non", "-", "deliverable", "message", "." ]

[ "@", "Override", "protected", "CollectionMatch", "getCollectionMatchForWebResourceCollection", "(", "WebResourceCollection", "webResourceCollection", ",", "String", "resourceName", ",", "String", "method", ")", "{", "CollectionMatch", "match", "=", "null", ";", "CollectionMatch", "collectionMatchFound", "=", "webResourceCollection", ".", "performUrlMatch", "(", "resourceName", ")", ";", "if", "(", "collectionMatchFound", "!=", "null", ")", "{", "if", "(", "webResourceCollection", ".", "isMethodMatched", "(", "method", ")", ")", "{", "match", "=", "collectionMatchFound", ";", "}", "else", "if", "(", "webResourceCollection", ".", "isMethodListed", "(", "method", ")", ")", "{", "match", "=", "CollectionMatch", ".", "RESPONSE_NO_MATCH", ";", "}", "}", "else", "{", "match", "=", "CollectionMatch", ".", "RESPONSE_NO_MATCH", ";", "}", "return", "match", ";", "}" ]

[ "Gets", "the", "collection", "match", "for", "the", "web", "resource", "collection", "based", "on", "the", "following", "custom", "method", "algorithm", ".", "<pre", ">", "Custom", "method", "matching", "use", "case", ".", "Happy", "path", ":", "1", ".", "Validate", "the", "resource", "name", "matches", "one", "of", "the", "URL", "patterns", "2", ".", "Validate", "the", "method", "matches", "3", ".", "Return", "the", "collection", "match", "found" ]

[ "public", "static", "void", "assertNoPrimitiveParameters", "(", "final", "Method", "method", ",", "Class", "<", "?", "extends", "Annotation", ">", "annotation", ")", "{", "for", "(", "Class", "<", "?", ">", "type", ":", "method", ".", "getParameterTypes", "(", ")", ")", "{", "if", "(", "type", ".", "isPrimitive", "(", ")", ")", "{", "throw", "annotation", "==", "null", "?", "MESSAGES", ".", "methodCannotDeclarePrimitiveParameters", "(", "method", ")", ":", "MESSAGES", ".", "methodCannotDeclarePrimitiveParameters2", "(", "method", ",", "annotation", ")", ";", "}", "}", "}" ]

[ "Asserts", "method", "don", "t", "declare", "primitive", "parameters", "." ]

[ "public", "String", "getNamespaceForPrefix", "(", "String", "prefix", ",", "Element", "namespaceContext", ")", "{", "int", "type", ";", "Node", "parent", "=", "namespaceContext", ";", "String", "namespace", "=", "null", ";", "if", "(", "prefix", ".", "equals", "(", "\"xml\"", ")", ")", "{", "namespace", "=", "QName", ".", "S_XMLNAMESPACEURI", ";", "// Hardcoded, per Namespace spec", "}", "else", "if", "(", "prefix", ".", "equals", "(", "\"xmlns\"", ")", ")", "{", "// Hardcoded in the DOM spec, expected to be adopted by", "// Namespace spec. NOTE: Namespace declarations _must_ use", "// the xmlns: prefix; other prefixes declared as belonging", "// to this namespace will not be recognized and should", "// probably be rejected by parsers as erroneous declarations.", "namespace", "=", "\"http://www.w3.org/2000/xmlns/\"", ";", "}", "else", "{", "// Attribute name for this prefix's declaration", "String", "declname", "=", "(", "prefix", "==", "\"\"", ")", "?", "\"xmlns\"", ":", "\"xmlns:\"", "+", "prefix", ";", "// Scan until we run out of Elements or have resolved the namespace", "while", "(", "(", "null", "!=", "parent", ")", "&&", "(", "null", "==", "namespace", ")", "&&", "(", "(", "(", "type", "=", "parent", ".", "getNodeType", "(", ")", ")", "==", "Node", ".", "ELEMENT_NODE", ")", "||", "(", "type", "==", "Node", ".", "ENTITY_REFERENCE_NODE", ")", ")", ")", "{", "if", "(", "type", "==", "Node", ".", "ELEMENT_NODE", ")", "{", "// Look for the appropriate Namespace Declaration attribute,", "// either \"xmlns:prefix\" or (if prefix is \"\") \"xmlns\".", "// TODO: This does not handle \"implicit declarations\"", "// which may be created when the DOM is edited. DOM Level", "// 3 will define how those should be interpreted. But", "// this issue won't arise in freshly-parsed DOMs.", "// NOTE: declname is set earlier, outside the loop.", "Attr", "attr", "=", "(", "(", "Element", ")", "parent", ")", ".", "getAttributeNode", "(", "declname", ")", ";", "if", "(", "attr", "!=", "null", ")", "{", "namespace", "=", "attr", ".", "getNodeValue", "(", ")", ";", "break", ";", "}", "}", "parent", "=", "getParentOfNode", "(", "parent", ")", ";", "}", "}", "return", "namespace", ";", "}" ]

[ "Given", "an", "XML", "Namespace", "prefix", "and", "a", "context", "in", "which", "the", "prefix", "is", "to", "be", "evaluated", "return", "the", "Namespace", "Name", "this", "prefix", "was", "bound", "to", ".", "Note", "that", "DOM", "Level", "3", "is", "expected", "to", "provide", "a", "version", "of", "this", "which", "deals", "with", "the", "DOM", "s", "early", "binding", "behavior", "." ]

[ "public", "boolean", "containsRow", "(", "Map", "<", "String", ",", "String", ">", "row", ")", "{", "for", "(", "CsvRow", "csvRow", ":", "data", ")", "{", "if", "(", "csvRow", ".", "contains", "(", "row", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Test", "if", "this", "Csv", "contains", "specified", "row", ".", "Note", ":", "Provided", "row", "may", "only", "contain", "part", "of", "the", "columns", "." ]

[ "public", "ManagedEntity", "findChild", "(", "ManagedEntity", "parent", ",", "String", "name", ")", "throws", "RuntimeFault", ",", "RemoteException", "{", "if", "(", "parent", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"parent entity must not be null.\"", ")", ";", "}", "ManagedObjectReference", "mor", "=", "getVimService", "(", ")", ".", "findChild", "(", "getMOR", "(", ")", ",", "parent", ".", "getMOR", "(", ")", ",", "name", ")", ";", "return", "MorUtil", ".", "createExactManagedEntity", "(", "getServerConnection", "(", ")", ",", "mor", ")", ";", "}" ]

[ "Find", "a", "child", "entity", "under", "a", "ManagedObjectReference", "in", "the", "inventory", "." ]

[ "public", "void", "deleteFromComputeNode", "(", "String", "poolId", ",", "String", "nodeId", ",", "String", "filePath", ")", "{", "deleteFromComputeNodeWithServiceResponseAsync", "(", "poolId", ",", "nodeId", ",", "filePath", ")", ".", "toBlocking", "(", ")", ".", "single", "(", ")", ".", "body", "(", ")", ";", "}" ]

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

[ "protected", "JSONObject", "toReponsiveImageSource", "(", "Media", "media", ",", "MediaFormat", "mediaFormat", ")", "{", "String", "url", "=", "buildDummyImageUrl", "(", "mediaFormat", ")", ";", "try", "{", "JSONObject", "source", "=", "new", "JSONObject", "(", ")", ";", "source", ".", "put", "(", "MediaNameConstants", ".", "PROP_BREAKPOINT", ",", "mediaFormat", ".", "getProperties", "(", ")", ".", "get", "(", "MediaNameConstants", ".", "PROP_BREAKPOINT", ")", ")", ";", "source", ".", "put", "(", "ResponsiveImageMediaMarkupBuilder", ".", "PROP_SRC", ",", "url", ")", ";", "return", "source", ";", "}", "catch", "(", "JSONException", "ex", ")", "{", "throw", "new", "RuntimeException", "(", "\"Error building JSON source.\"", ",", "ex", ")", ";", "}", "}" ]

[ "Build", "JSON", "metadata", "for", "one", "rendition", "as", "image", "source", "." ]

[ "protected", "void", "selectBestRegionsFern", "(", "double", "totalP", ",", "double", "totalN", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "fernInfo", ".", "size", ";", "i", "++", ")", "{", "TldRegionFernInfo", "info", "=", "fernInfo", ".", "get", "(", "i", ")", ";", "double", "probP", "=", "info", ".", "sumP", "/", "totalP", ";", "double", "probN", "=", "info", ".", "sumN", "/", "totalN", ";", "// only consider regions with a higher P likelihood", "if", "(", "probP", ">", "probN", ")", "{", "// reward regions with a large difference between the P and N values", "storageMetric", ".", "add", "(", "-", "(", "probP", "-", "probN", ")", ")", ";", "storageRect", ".", "add", "(", "info", ".", "r", ")", ";", "}", "}", "// Select the N regions with the highest fern probability", "if", "(", "config", ".", "maximumCascadeConsider", "<", "storageMetric", ".", "size", ")", "{", "int", "N", "=", "Math", ".", "min", "(", "config", ".", "maximumCascadeConsider", ",", "storageMetric", ".", "size", ")", ";", "storageIndexes", ".", "resize", "(", "storageMetric", ".", "size", ")", ";", "QuickSelect", ".", "selectIndex", "(", "storageMetric", ".", "data", ",", "N", "-", "1", ",", "storageMetric", ".", "size", ",", "storageIndexes", ".", "data", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "N", ";", "i", "++", ")", "{", "fernRegions", ".", "add", "(", "storageRect", ".", "get", "(", "storageIndexes", ".", "get", "(", "i", ")", ")", ")", ";", "}", "}", "else", "{", "fernRegions", ".", "addAll", "(", "storageRect", ")", ";", "}", "}" ]

[ "compute", "the", "probability", "that", "each", "region", "is", "the", "target", "conditional", "upon", "this", "image", "the", "sumP", "and", "sumN", "are", "needed", "for", "image", "conditional", "probability" ]

[ "@", "NotNull", "Set", "<", "ApolloMutationCall", ">", "activeMutationCalls", "(", "@", "NotNull", "OperationName", "operationName", ")", "{", "return", "activeCalls", "(", "activeMutationCalls", ",", "operationName", ")", ";", "}" ]

[ "Returns", "currently", "active", "{", "@link", "ApolloMutationCall", "}", "calls", "by", "operation", "name", "." ]

[ "public", "static", "MenuItem", "newMenuItem", "(", "final", "Class", "<", "?", "extends", "Page", ">", "pageClass", ",", "final", "String", "resourceModelKey", ",", "final", "Component", "component", ",", "final", "PageParameters", "parameters", ")", "{", "final", "BookmarkablePageLink", "<", "String", ">", "bookmarkablePageLink", "=", "new", "BookmarkablePageLink", "<>", "(", "MenuPanel", ".", "LINK_ID", ",", "pageClass", ",", "parameters", ")", ";", "final", "IModel", "<", "String", ">", "labelModel", "=", "ResourceModelFactory", ".", "newResourceModel", "(", "resourceModelKey", ",", "component", ")", ";", "final", "MenuItem", "menuItem", "=", "new", "MenuItem", "(", "bookmarkablePageLink", ",", "labelModel", ")", ";", "return", "menuItem", ";", "}" ]

[ "Creates", "the", "menu", "item", "." ]

[ "protected", "Predicate", "createPredicate", "(", "Path", "root", ",", "CriteriaQuery", "<", "?", ">", "query", ",", "CriteriaBuilder", "cb", ",", "String", "propertyName", ",", "ComparisonOperator", "operator", ",", "Object", "argument", ",", "PersistenceContext", "context", ")", "{", "logger", ".", "debug", "(", "\"Creating criterion: {} {} {}\"", ",", "propertyName", ",", "operator", ",", "argument", ")", ";", "switch", "(", "operator", ")", "{", "case", "EQUAL", ":", "{", "if", "(", "containWildcard", "(", "argument", ")", ")", "{", "return", "createLike", "(", "root", ",", "query", ",", "cb", ",", "propertyName", ",", "argument", ",", "context", ")", ";", "}", "else", "{", "return", "createEqual", "(", "root", ",", "query", ",", "cb", ",", "propertyName", ",", "argument", ",", "context", ")", ";", "}", "}", "case", "NOT_EQUAL", ":", "{", "if", "(", "containWildcard", "(", "argument", ")", ")", "{", "return", "createNotLike", "(", "root", ",", "query", ",", "cb", ",", "propertyName", ",", "argument", ",", "context", ")", ";", "}", "else", "{", "return", "createNotEqual", "(", "root", ",", "query", ",", "cb", ",", "propertyName", ",", "argument", ",", "context", ")", ";", "}", "}", "case", "GREATER_THAN", ":", "return", "createGreaterThan", "(", "root", ",", "query", ",", "cb", ",", "propertyName", ",", "argument", ",", "context", ")", ";", "case", "GREATER_EQUAL", ":", "return", "createGreaterEqual", "(", "root", ",", "query", ",", "cb", ",", "propertyName", ",", "argument", ",", "context", ")", ";", "case", "LESS_THAN", ":", "return", "createLessThan", "(", "root", ",", "query", ",", "cb", ",", "propertyName", ",", "argument", ",", "context", ")", ";", "case", "LESS_EQUAL", ":", "return", "createLessEqual", "(", "root", ",", "query", ",", "cb", ",", "propertyName", ",", "argument", ",", "context", ")", ";", "case", "IN", ":", "return", "createIn", "(", "root", ",", "query", ",", "cb", ",", "propertyName", ",", "argument", ",", "context", ")", ";", "case", "NOT_IN", ":", "return", "createNotIn", "(", "root", ",", "query", ",", "cb", ",", "propertyName", ",", "argument", ",", "context", ")", ";", "}", "throw", "new", "IllegalArgumentException", "(", "\"Unknown operator: \"", "+", "operator", ")", ";", "}" ]

[ "Delegate", "creating", "of", "a", "Predicate", "to", "an", "appropriate", "method", "according", "to", "operator", "." ]

[ "public", "static", "boolean", "decodeBooleanDesc", "(", "byte", "[", "]", "src", ",", "int", "srcOffset", ")", "throws", "CorruptEncodingException", "{", "try", "{", "return", "src", "[", "srcOffset", "]", "==", "127", ";", "}", "catch", "(", "IndexOutOfBoundsException", "e", ")", "{", "throw", "new", "CorruptEncodingException", "(", "null", ",", "e", ")", ";", "}", "}" ]

[ "Decodes", "a", "boolean", "from", "exactly", "1", "byte", "as", "encoded", "for", "descending", "order", "." ]

[ "public", "static", "<", "K", ",", "V", ",", "C", "extends", "IMap", "<", "K", ",", "V", ">", ">", "C", "monitor", "(", "MeterRegistry", "registry", ",", "C", "cache", ",", "Iterable", "<", "Tag", ">", "tags", ")", "{", "new", "HazelcastCacheMetrics", "(", "cache", ",", "tags", ")", ".", "bindTo", "(", "registry", ")", ";", "return", "cache", ";", "}" ]

[ "Record", "metrics", "on", "a", "Hazelcast", "cache", "." ]

[ "public", "static", "boolean", "copy", "(", "InputStream", "source", ",", "ByteBuffer", "destination", ")", "{", "try", "{", "byte", "[", "]", "buffer", "=", "new", "byte", "[", "4096", "]", ";", "int", "n", "=", "0", ";", "while", "(", "-", "1", "!=", "(", "n", "=", "source", ".", "read", "(", "buffer", ")", ")", ")", "{", "destination", ".", "put", "(", "buffer", ",", "0", ",", "n", ")", ";", "}", "return", "true", ";", "}", "catch", "(", "IOException", "e", ")", "{", "return", "false", ";", "}", "}" ]

[ "This", "method", "should", "only", "be", "used", "when", "the", "ByteBuffer", "is", "known", "to", "be", "able", "to", "accomodate", "the", "input!" ]

[ "public", "static", "void", "searchInFile", "(", "Pattern", "p", ",", "String", "inFile", ",", "String", "outFile", ")", "throws", "FileNotFoundException", "{", "searchInFile", "(", "p", ",", "inFile", ",", "outFile", ",", "Integer", ".", "MAX_VALUE", ",", "Integer", ".", "MAX_VALUE", ")", ";", "}" ]

[ "Searches", "a", "pattern", "reading", "the", "model", "from", "the", "given", "file", "and", "creates", "another", "model", "that", "is", "excised", "using", "the", "matching", "patterns", "." ]

[ "synchronized", "void", "updateJobInfo", "(", "long", "startTime", ",", "long", "launchTime", ")", "{", "// log and change to the job's start/launch time", "this", ".", "startTime", "=", "startTime", ";", "this", ".", "launchTime", "=", "launchTime", ";", "JobHistory", ".", "JobInfo", ".", "logJobInfo", "(", "jobId", ",", "startTime", ",", "launchTime", ")", ";", "}" ]

[ "Update", "the", "job", "start", "/", "launch", "time", "(", "upon", "restart", ")", "and", "log", "to", "history" ]

[ "public", "net", ".", "minidev", ".", "ovh", ".", "api", ".", "vrack", ".", "OvhTask", "serviceName_vrack_vrack_DELETE", "(", "String", "serviceName", ",", "String", "vrack", ")", "throws", "IOException", "{", "String", "qPath", "=", "\"/dedicatedCloud/{serviceName}/vrack/{vrack}\"", ";", "StringBuilder", "sb", "=", "path", "(", "qPath", ",", "serviceName", ",", "vrack", ")", ";", "String", "resp", "=", "exec", "(", "qPath", ",", "\"DELETE\"", ",", "sb", ".", "toString", "(", ")", ",", "null", ")", ";", "return", "convertTo", "(", "resp", ",", "net", ".", "minidev", ".", "ovh", ".", "api", ".", "vrack", ".", "OvhTask", ".", "class", ")", ";", "}" ]

[ "remove", "this", "dedicatedCloud", "(", "VmNetwork", ")", "from", "this", "vrack" ]

[ "@", "Path", "(", "\"/acl/{spaceID}\"", ")", "@", "POST", "public", "Response", "updateSpaceACLs", "(", "@", "PathParam", "(", "\"spaceID\"", ")", "String", "spaceID", ",", "@", "QueryParam", "(", "\"storeID\"", ")", "String", "storeID", ")", "{", "String", "msg", "=", "\"update space ACLs(\"", "+", "spaceID", "+", "\", \"", "+", "storeID", "+", "\")\"", ";", "try", "{", "log", ".", "debug", "(", "msg", ")", ";", "return", "doUpdateSpaceACLs", "(", "spaceID", ",", "storeID", ")", ";", "}", "catch", "(", "ResourceNotFoundException", "e", ")", "{", "return", "responseNotFound", "(", "msg", ",", "e", ",", "NOT_FOUND", ")", ";", "}", "catch", "(", "ResourceException", "e", ")", "{", "return", "responseBad", "(", "msg", ",", "e", ",", "INTERNAL_SERVER_ERROR", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "return", "responseBad", "(", "msg", ",", "e", ",", "INTERNAL_SERVER_ERROR", ")", ";", "}", "}" ]

[ "This", "method", "sets", "the", "ACLs", "associated", "with", "a", "space", ".", "Only", "values", "included", "in", "the", "ACLs", "headers", "will", "be", "updated", "others", "will", "be", "removed", "." ]

[ "private", "AnimationListener", "createAnimationListener", "(", "final", "boolean", "show", ",", "final", "boolean", "cancel", ")", "{", "return", "new", "AnimationListener", "(", ")", "{", "@", "Override", "public", "void", "onAnimationStart", "(", "final", "Animation", "animation", ")", "{", "}", "@", "Override", "public", "void", "onAnimationEnd", "(", "final", "Animation", "animation", ")", "{", "clearAnimation", "(", ")", ";", "maximized", "=", "show", ";", "if", "(", "maximized", ")", "{", "notifyOnMaximized", "(", ")", ";", "}", "else", "{", "notifyOnHidden", "(", "cancel", ")", ";", "}", "}", "@", "Override", "public", "void", "onAnimationRepeat", "(", "final", "Animation", "animation", ")", "{", "}", "}", ";", "}" ]

[ "Creates", "and", "returns", "a", "listener", "which", "allows", "to", "handle", "the", "end", "of", "an", "animation", "which", "has", "been", "used", "to", "show", "or", "hide", "the", "view", "." ]

[ "File", "setSnapshotFile", "(", "File", "tempFile", ",", "Zxid", "zxid", ")", "throws", "IOException", "{", "File", "snapshot", "=", "new", "File", "(", "dataDir", ",", "String", ".", "format", "(", "\"snapshot.%s\"", ",", "zxid", ".", "toSimpleString", "(", ")", ")", ")", ";", "LOG", ".", "debug", "(", "\"Atomically move snapshot file to {}\"", ",", "snapshot", ")", ";", "FileUtils", ".", "atomicMove", "(", "tempFile", ",", "snapshot", ")", ";", "// Since the new snapshot file gets created, we need to fsync the directory.", "fsyncDirectory", "(", ")", ";", "return", "snapshot", ";", "}" ]

[ "Turns", "a", "temporary", "snapshot", "file", "into", "a", "valid", "snapshot", "file", "." ]

[ "private", "QueryBuilder", "populateBetweenFilter", "(", "BetweenExpression", "betweenExpression", ",", "EntityMetadata", "m", ")", "{", "String", "lowerBoundExpression", "=", "getBetweenBoundaryValues", "(", "betweenExpression", ".", "getLowerBoundExpression", "(", ")", ")", ";", "String", "upperBoundExpression", "=", "getBetweenBoundaryValues", "(", "betweenExpression", ".", "getUpperBoundExpression", "(", ")", ")", ";", "String", "field", "=", "getField", "(", "betweenExpression", ".", "getExpression", "(", ")", ".", "toParsedText", "(", ")", ")", ";", "log", ".", "debug", "(", "\"Between clause for field \"", "+", "field", "+", "\"with lower bound \"", "+", "lowerBoundExpression", "+", "\"and upper bound \"", "+", "upperBoundExpression", ")", ";", "return", "new", "AndQueryBuilder", "(", "getFilter", "(", "kunderaQuery", ".", "new", "FilterClause", "(", "field", ",", "Expression", ".", "GREATER_THAN_OR_EQUAL", ",", "lowerBoundExpression", ",", "field", ")", ",", "m", ")", ",", "getFilter", "(", "kunderaQuery", ".", "new", "FilterClause", "(", "field", ",", "Expression", ".", "LOWER_THAN_OR_EQUAL", ",", "upperBoundExpression", ",", "field", ")", ",", "m", ")", ")", ";", "}" ]

[ "Populate", "between", "filter", "." ]

[ "public", "static", "HostController", "createHostController", "(", "String", "jbossHomePath", ",", "String", "modulePath", ",", "String", "[", "]", "systemPackages", ",", "String", "[", "]", "cmdargs", ")", "{", "if", "(", "jbossHomePath", "==", "null", "||", "jbossHomePath", ".", "isEmpty", "(", ")", ")", "{", "throw", "EmbeddedLogger", ".", "ROOT_LOGGER", ".", "invalidJBossHome", "(", "jbossHomePath", ")", ";", "}", "File", "jbossHomeDir", "=", "new", "File", "(", "jbossHomePath", ")", ";", "if", "(", "!", "jbossHomeDir", ".", "isDirectory", "(", ")", ")", "{", "throw", "EmbeddedLogger", ".", "ROOT_LOGGER", ".", "invalidJBossHome", "(", "jbossHomePath", ")", ";", "}", "return", "createHostController", "(", "Configuration", ".", "Builder", ".", "of", "(", "jbossHomeDir", ")", ".", "setModulePath", "(", "modulePath", ")", ".", "setSystemPackages", "(", "systemPackages", ")", ".", "setCommandArguments", "(", "cmdargs", ")", ".", "build", "(", ")", ")", ";", "}" ]

[ "Create", "an", "embedded", "host", "controller", "." ]

[ "public", "static", "String", "formatDate", "(", "Date", "date", ",", "String", "pattern", ")", "{", "SimpleDateFormat", "formatter", "=", "new", "SimpleDateFormat", "(", "pattern", ",", "Locale", ".", "US", ")", ";", "formatter", ".", "setTimeZone", "(", "GMT", ")", ";", "return", "formatter", ".", "format", "(", "date", ")", ";", "}" ]

[ "Formats", "the", "given", "date", "according", "to", "the", "specified", "pattern", ".", "The", "pattern", "must", "conform", "to", "that", "used", "by", "the", "{", "@link", "SimpleDateFormat", "simple", "date", "format", "}", "class", "." ]

[ "public", "PartitionSize", "getSize", "(", "Date", "first", ",", "Date", "last", ",", "int", "maxP", ")", "{", "long", "diffMS", "=", "last", ".", "getTime", "(", ")", "-", "first", ".", "getTime", "(", ")", ";", "for", "(", "PartitionSize", "pa", ":", "sizes", ")", "{", "long", "maxMS", "=", "maxP", "*", "pa", ".", "intervalMS", "(", ")", ";", "if", "(", "maxMS", ">", "diffMS", ")", "{", "return", "pa", ";", "}", "}", "return", "twoYearSize", ";", "}" ]

[ "Attempt", "to", "find", "the", "smallest", "PartitionSize", "implementation", "which", "spanning", "the", "range", "first", "and", "last", "specified", "produces", "at", "most", "maxP", "partitions", "." ]

[ "public", "void", "decrease", "(", "final", "DeviceControllerChannel", "channel", ",", "final", "int", "steps", ")", "throws", "IOException", "{", "if", "(", "channel", "==", "null", ")", "{", "throw", "new", "RuntimeException", "(", "\"null-channel is not allowed. For devices \"", "+", "\"knowing just one wiper Channel.A is mandatory for \"", "+", "\"parameter 'channel'\"", ")", ";", "}", "// decrease only works on volatile-wiper", "byte", "memAddr", "=", "channel", ".", "getVolatileMemoryAddress", "(", ")", ";", "increaseOrDecrease", "(", "memAddr", ",", "false", ",", "steps", ")", ";", "}" ]

[ "Decrements", "the", "volatile", "wiper", "for", "the", "given", "number", "steps", "." ]

[ "public", "void", "updateRemoteFilterProperties", "(", "BaseMessageFilter", "messageFilter", ",", "Object", "[", "]", "[", "]", "properties", ",", "Map", "<", "String", ",", "Object", ">", "propFilter", ")", "throws", "RemoteException", "{", "BaseTransport", "transport", "=", "this", ".", "createProxyTransport", "(", "REMOVE_REMOTE_MESSAGE_FILTER", ")", ";", "transport", ".", "addParam", "(", "FILTER", ",", "messageFilter", ")", ";", "// Don't use COMMAND", "transport", ".", "addParam", "(", "PROPERTIES", ",", "properties", ")", ";", "transport", ".", "addParam", "(", "MAP", ",", "propFilter", ")", ";", "transport", ".", "sendMessageAndGetReply", "(", ")", ";", "}" ]

[ "Update", "this", "filter", "with", "this", "new", "information", "." ]

[ "@", "RequestMapping", "(", "value", "=", "\"api/group/{groupId}/{overrideId}\"", ",", "method", "=", "RequestMethod", ".", "DELETE", ")", "public", "@", "ResponseBody", "String", "removeOverride", "(", "Model", "model", ",", "@", "PathVariable", "int", "overrideId", ")", "{", "pathOverrideService", ".", "removeOverride", "(", "overrideId", ")", ";", "return", "null", ";", "}" ]

[ "Remove", "an", "override", "from", "a", "group" ]

[ "public", "boolean", "canResolveTo", "(", "LightweightTypeReference", "reference", ")", "{", "if", "(", "internalIsResolved", "(", ")", ")", "return", "reference", ".", "isAssignableFrom", "(", "resolvedTo", ",", "new", "TypeConformanceComputationArgument", "(", "false", ",", "true", ",", "true", ",", "true", ",", "false", ",", "false", "/* TODO do we need to support synonmys here? */", ")", ")", ";", "List", "<", "LightweightBoundTypeArgument", ">", "hints", "=", "getAllHints", "(", ")", ";", "if", "(", "!", "hints", ".", "isEmpty", "(", ")", "&&", "hasSignificantHints", "(", "hints", ")", ")", "{", "return", "canResolveTo", "(", "reference", ",", "hints", ")", ";", "}", "return", "false", ";", "}" ]

[ "Returns", "true", "if", "the", "existing", "hints", "would", "allow", "to", "resolve", "to", "the", "given", "reference", "." ]

[ "public", "static", "LayerConstraint", "mapConstraint", "(", "String", "kerasConstraint", ",", "KerasLayerConfiguration", "conf", ",", "Map", "<", "String", ",", "Object", ">", "constraintConfig", ")", "throws", "UnsupportedKerasConfigurationException", "{", "LayerConstraint", "constraint", ";", "if", "(", "kerasConstraint", ".", "equals", "(", "conf", ".", "getLAYER_FIELD_MINMAX_NORM_CONSTRAINT", "(", ")", ")", "||", "kerasConstraint", ".", "equals", "(", "conf", ".", "getLAYER_FIELD_MINMAX_NORM_CONSTRAINT_ALIAS", "(", ")", ")", ")", "{", "double", "min", "=", "(", "double", ")", "constraintConfig", ".", "get", "(", "conf", ".", "getLAYER_FIELD_MINMAX_MIN_CONSTRAINT", "(", ")", ")", ";", "double", "max", "=", "(", "double", ")", "constraintConfig", ".", "get", "(", "conf", ".", "getLAYER_FIELD_MINMAX_MAX_CONSTRAINT", "(", ")", ")", ";", "double", "rate", "=", "(", "double", ")", "constraintConfig", ".", "get", "(", "conf", ".", "getLAYER_FIELD_CONSTRAINT_RATE", "(", ")", ")", ";", "int", "dim", "=", "(", "int", ")", "constraintConfig", ".", "get", "(", "conf", ".", "getLAYER_FIELD_CONSTRAINT_DIM", "(", ")", ")", ";", "constraint", "=", "new", "MinMaxNormConstraint", "(", "min", ",", "max", ",", "rate", ",", "dim", "+", "1", ")", ";", "}", "else", "if", "(", "kerasConstraint", ".", "equals", "(", "conf", ".", "getLAYER_FIELD_MAX_NORM_CONSTRAINT", "(", ")", ")", "||", "kerasConstraint", ".", "equals", "(", "conf", ".", "getLAYER_FIELD_MAX_NORM_CONSTRAINT_ALIAS", "(", ")", ")", "||", "kerasConstraint", ".", "equals", "(", "conf", ".", "getLAYER_FIELD_MAX_NORM_CONSTRAINT_ALIAS_2", "(", ")", ")", ")", "{", "double", "max", "=", "(", "double", ")", "constraintConfig", ".", "get", "(", "conf", ".", "getLAYER_FIELD_MAX_CONSTRAINT", "(", ")", ")", ";", "int", "dim", "=", "(", "int", ")", "constraintConfig", ".", "get", "(", "conf", ".", "getLAYER_FIELD_CONSTRAINT_DIM", "(", ")", ")", ";", "constraint", "=", "new", "MaxNormConstraint", "(", "max", ",", "dim", "+", "1", ")", ";", "}", "else", "if", "(", "kerasConstraint", ".", "equals", "(", "conf", ".", "getLAYER_FIELD_UNIT_NORM_CONSTRAINT", "(", ")", ")", "||", "kerasConstraint", ".", "equals", "(", "conf", ".", "getLAYER_FIELD_UNIT_NORM_CONSTRAINT_ALIAS", "(", ")", ")", "||", "kerasConstraint", ".", "equals", "(", "conf", ".", "getLAYER_FIELD_UNIT_NORM_CONSTRAINT_ALIAS_2", "(", ")", ")", ")", "{", "int", "dim", "=", "(", "int", ")", "constraintConfig", ".", "get", "(", "conf", ".", "getLAYER_FIELD_CONSTRAINT_DIM", "(", ")", ")", ";", "constraint", "=", "new", "UnitNormConstraint", "(", "dim", "+", "1", ")", ";", "}", "else", "if", "(", "kerasConstraint", ".", "equals", "(", "conf", ".", "getLAYER_FIELD_NON_NEG_CONSTRAINT", "(", ")", ")", "||", "kerasConstraint", ".", "equals", "(", "conf", ".", "getLAYER_FIELD_NON_NEG_CONSTRAINT_ALIAS", "(", ")", ")", "||", "kerasConstraint", ".", "equals", "(", "conf", ".", "getLAYER_FIELD_NON_NEG_CONSTRAINT_ALIAS_2", "(", ")", ")", ")", "{", "constraint", "=", "new", "NonNegativeConstraint", "(", ")", ";", "}", "else", "{", "throw", "new", "UnsupportedKerasConfigurationException", "(", "\"Unknown keras constraint \"", "+", "kerasConstraint", ")", ";", "}", "return", "constraint", ";", "}" ]

[ "Map", "Keras", "to", "DL4J", "constraint", "." ]

[ "public", "void", "serviceName_http_farm_farmId_PUT", "(", "String", "serviceName", ",", "Long", "farmId", ",", "OvhBackendHttp", "body", ")", "throws", "IOException", "{", "String", "qPath", "=", "\"/ipLoadbalancing/{serviceName}/http/farm/{farmId}\"", ";", "StringBuilder", "sb", "=", "path", "(", "qPath", ",", "serviceName", ",", "farmId", ")", ";", "exec", "(", "qPath", ",", "\"PUT\"", ",", "sb", ".", "toString", "(", ")", ",", "body", ")", ";", "}" ]

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

[ "public", "void", "setMapPosition", "(", "final", "Object", "targetObj", ",", "final", "CellPosition", "position", ",", "final", "String", "key", ")", "{", "ArgUtils", ".", "notNull", "(", "targetObj", ",", "\"targetObj\"", ")", ";", "ArgUtils", ".", "notNull", "(", "position", ",", "\"position\"", ")", ";", "ArgUtils", ".", "notEmpty", "(", "key", ",", "\"key\"", ")", ";", "mapPositionSetter", ".", "ifPresent", "(", "setter", "->", "setter", ".", "set", "(", "targetObj", ",", "position", ",", "key", ")", ")", ";", "}" ]

[ "{", "@link", "XlsMapColumns", "}", "フィールド用の位置情報を設定します。", "<p", ">", "位置情報を保持するフィールドがない場合は、処理はスキップされます。<", "/", "p", ">" ]

[ "public", "Sight", "moveSight", "(", "long", "sightId", ",", "ContainerDestination", "destination", ")", "throws", "SmartsheetException", "{", "return", "this", ".", "createResource", "(", "\"sights/\"", "+", "sightId", "+", "\"/move\"", ",", "Sight", ".", "class", ",", "destination", ")", ";", "}" ]

[ "Creates", "s", "copy", "of", "the", "specified", "Sight", "." ]

[ "public", "LineElement", "generateInnerElement", "(", "IBond", "bond", ",", "IRing", "ring", ",", "RendererModel", "model", ")", "{", "Point2d", "center", "=", "GeometryUtil", ".", "get2DCenter", "(", "ring", ")", ";", "Point2d", "a", "=", "bond", ".", "getBegin", "(", ")", ".", "getPoint2d", "(", ")", ";", "Point2d", "b", "=", "bond", ".", "getEnd", "(", ")", ".", "getPoint2d", "(", ")", ";", "// the proportion to move in towards the ring center", "double", "distanceFactor", "=", "model", ".", "getParameter", "(", "TowardsRingCenterProportion", ".", "class", ")", ".", "getValue", "(", ")", ";", "double", "ringDistance", "=", "distanceFactor", "*", "IDEAL_RINGSIZE", "/", "ring", ".", "getAtomCount", "(", ")", ";", "if", "(", "ringDistance", "<", "distanceFactor", "/", "MIN_RINGSIZE_FACTOR", ")", "ringDistance", "=", "distanceFactor", "/", "MIN_RINGSIZE_FACTOR", ";", "Point2d", "w", "=", "new", "Point2d", "(", ")", ";", "w", ".", "interpolate", "(", "a", ",", "center", ",", "ringDistance", ")", ";", "Point2d", "u", "=", "new", "Point2d", "(", ")", ";", "u", ".", "interpolate", "(", "b", ",", "center", ",", "ringDistance", ")", ";", "double", "alpha", "=", "0.2", ";", "Point2d", "ww", "=", "new", "Point2d", "(", ")", ";", "ww", ".", "interpolate", "(", "w", ",", "u", ",", "alpha", ")", ";", "Point2d", "uu", "=", "new", "Point2d", "(", ")", ";", "uu", ".", "interpolate", "(", "u", ",", "w", ",", "alpha", ")", ";", "double", "width", "=", "getWidthForBond", "(", "bond", ",", "model", ")", ";", "Color", "color", "=", "getColorForBond", "(", "bond", ",", "model", ")", ";", "return", "new", "LineElement", "(", "u", ".", "x", ",", "u", ".", "y", ",", "w", ".", "x", ",", "w", ".", "y", ",", "width", ",", "color", ")", ";", "}" ]

[ "Make", "the", "inner", "ring", "bond", "which", "is", "slightly", "shorter", "than", "the", "outer", "bond", "." ]

[ "@", "Deprecated", "public", "static", "String", "splitAndIndent", "(", "String", "str", ",", "int", "indent", ",", "int", "numChars", ")", "{", "final", "int", "inputLength", "=", "str", ".", "length", "(", ")", ";", "// to prevent resizing, we can predict the size of the indented string", "// the formatting addition is the indent spaces plus a newline", "// this length is added once for each line", "boolean", "perfectFit", "=", "(", "inputLength", "%", "numChars", "==", "0", ")", ";", "int", "fullLines", "=", "(", "inputLength", "/", "numChars", ")", ";", "int", "formatLength", "=", "perfectFit", "?", "(", "indent", "+", "1", ")", "*", "fullLines", ":", "(", "indent", "+", "1", ")", "*", "(", "fullLines", "+", "1", ")", ";", "int", "outputLength", "=", "inputLength", "+", "formatLength", ";", "StringBuilder", "sb", "=", "new", "StringBuilder", "(", "outputLength", ")", ";", "for", "(", "int", "offset", "=", "0", ";", "offset", "<", "inputLength", ";", "offset", "+=", "numChars", ")", "{", "SpaceCharacters", ".", "indent", "(", "indent", ",", "sb", ")", ";", "sb", ".", "append", "(", "str", ",", "offset", ",", "Math", ".", "min", "(", "offset", "+", "numChars", ",", "inputLength", ")", ")", ";", "sb", ".", "append", "(", "'", "'", ")", ";", "}", "return", "sb", ".", "toString", "(", ")", ";", "}" ]

[ "Method", "that", "attempts", "to", "break", "a", "string", "up", "into", "lines", "no", "longer", "than", "the", "specified", "line", "length", "." ]

[ "public", "static", "Method", "setterMethod", "(", "Class", "<", "?", ">", "target", ",", "Class", "<", "?", ">", "componentClass", ")", "{", "try", "{", "return", "target", ".", "getMethod", "(", "setterName", "(", "componentClass", ")", ",", "componentClass", ")", ";", "}", "catch", "(", "NoSuchMethodException", "e", ")", "{", "//if (log.isTraceEnabled()) log.trace(\"Unable to find method \" + setterName(componentClass) + \" in class \" + target);", "return", "null", ";", "}", "catch", "(", "NullPointerException", "e", ")", "{", "return", "null", ";", "}", "}" ]

[ "Returns", "a", "Method", "object", "corresponding", "to", "a", "setter", "that", "sets", "an", "instance", "of", "componentClass", "from", "target", "." ]

[ "public", "Observable", "<", "ServiceResponse", "<", "Page", "<", "StorageAccountItem", ">", ">", ">", "getStorageAccountsWithServiceResponseAsync", "(", "final", "String", "vaultBaseUrl", ",", "final", "Integer", "maxresults", ")", "{", "return", "getStorageAccountsSinglePageAsync", "(", "vaultBaseUrl", ",", "maxresults", ")", ".", "concatMap", "(", "new", "Func1", "<", "ServiceResponse", "<", "Page", "<", "StorageAccountItem", ">", ">", ",", "Observable", "<", "ServiceResponse", "<", "Page", "<", "StorageAccountItem", ">", ">", ">", ">", "(", ")", "{", "@", "Override", "public", "Observable", "<", "ServiceResponse", "<", "Page", "<", "StorageAccountItem", ">", ">", ">", "call", "(", "ServiceResponse", "<", "Page", "<", "StorageAccountItem", ">", ">", "page", ")", "{", "String", "nextPageLink", "=", "page", ".", "body", "(", ")", ".", "nextPageLink", "(", ")", ";", "if", "(", "nextPageLink", "==", "null", ")", "{", "return", "Observable", ".", "just", "(", "page", ")", ";", "}", "return", "Observable", ".", "just", "(", "page", ")", ".", "concatWith", "(", "getStorageAccountsNextWithServiceResponseAsync", "(", "nextPageLink", ")", ")", ";", "}", "}", ")", ";", "}" ]

[ "List", "storage", "accounts", "managed", "by", "the", "specified", "key", "vault", ".", "This", "operation", "requires", "the", "storage", "/", "list", "permission", "." ]

[ "public", "void", "setNodeText", "(", "Node", "n", ",", "String", "text", ")", "{", "if", "(", "n", "==", "null", ")", "return", ";", "Node", "nc", "=", "null", ";", "while", "(", "(", "nc", "=", "n", ".", "getFirstChild", "(", ")", ")", "!=", "null", ")", "{", "n", ".", "removeChild", "(", "nc", ")", ";", "}", "if", "(", "n", ".", "getAttributes", "(", ")", ".", "getNamedItemNS", "(", "XFA_DATA_SCHEMA", ",", "\"dataNode\"", ")", "!=", "null", ")", "n", ".", "getAttributes", "(", ")", ".", "removeNamedItemNS", "(", "XFA_DATA_SCHEMA", ",", "\"dataNode\"", ")", ";", "n", ".", "appendChild", "(", "domDocument", ".", "createTextNode", "(", "text", ")", ")", ";", "changed", "=", "true", ";", "}" ]

[ "Sets", "the", "text", "of", "this", "node", ".", "All", "the", "child", "s", "node", "are", "deleted", "and", "a", "new", "child", "text", "node", "is", "created", "." ]

[ "public", "static", "int", "randomIntBetween", "(", "int", "min", ",", "int", "max", ")", "{", "Random", "rand", "=", "new", "Random", "(", ")", ";", "return", "rand", ".", "nextInt", "(", "(", "max", "-", "min", ")", "+", "1", ")", "+", "min", ";", "}" ]

[ "Returns", "an", "integer", "between", "interval" ]

[ "public", "static", "BoundedOverlay", "getLinkedFeatureOverlay", "(", "FeatureOverlay", "featureOverlay", ",", "GeoPackage", "geoPackage", ")", "{", "BoundedOverlay", "overlay", ";", "// Get the linked tile daos", "FeatureTileTableLinker", "linker", "=", "new", "FeatureTileTableLinker", "(", "geoPackage", ")", ";", "List", "<", "TileDao", ">", "tileDaos", "=", "linker", ".", "getTileDaosForFeatureTable", "(", "featureOverlay", ".", "getFeatureTiles", "(", ")", ".", "getFeatureDao", "(", ")", ".", "getTableName", "(", ")", ")", ";", "if", "(", "!", "tileDaos", ".", "isEmpty", "(", ")", ")", "{", "// Create a composite overlay to search for existing tiles before drawing from features", "overlay", "=", "getCompositeOverlay", "(", "tileDaos", ",", "featureOverlay", ")", ";", "}", "else", "{", "overlay", "=", "featureOverlay", ";", "}", "return", "overlay", ";", "}" ]

[ "Create", "a", "composite", "overlay", "linking", "the", "feature", "overly", "with" ]

[ "public", "static", "void", "populateAuthentication", "(", "final", "LinkedHashMap", "<", "String", ",", "CommonProfile", ">", "profiles", ")", "{", "if", "(", "profiles", "!=", "null", "&&", "profiles", ".", "size", "(", ")", ">", "0", ")", "{", "final", "List", "<", "CommonProfile", ">", "listProfiles", "=", "ProfileHelper", ".", "flatIntoAProfileList", "(", "profiles", ")", ";", "try", "{", "if", "(", "IS_FULLY_AUTHENTICATED_AUTHORIZER", ".", "isAuthorized", "(", "null", ",", "listProfiles", ")", ")", "{", "SecurityContextHolder", ".", "getContext", "(", ")", ".", "setAuthentication", "(", "new", "Pac4jAuthenticationToken", "(", "listProfiles", ")", ")", ";", "}", "else", "if", "(", "IS_REMEMBERED_AUTHORIZER", ".", "isAuthorized", "(", "null", ",", "listProfiles", ")", ")", "{", "SecurityContextHolder", ".", "getContext", "(", ")", ".", "setAuthentication", "(", "new", "Pac4jRememberMeAuthenticationToken", "(", "listProfiles", ")", ")", ";", "}", "}", "catch", "(", "final", "HttpAction", "e", ")", "{", "throw", "new", "TechnicalException", "(", "e", ")", ";", "}", "}", "}" ]

[ "Populate", "the", "authenticated", "user", "profiles", "in", "the", "Spring", "Security", "context", "." ]

[ "public", "static", "String", "decodeLZToString", "(", "byte", "[", "]", "data", ",", "String", "dictionary", ")", "{", "try", "{", "return", "new", "String", "(", "decodeLZ", "(", "data", ")", ",", "\"UTF-8\"", ")", ";", "}", "catch", "(", "UnsupportedEncodingException", "e", ")", "{", "throw", "new", "RuntimeException", "(", "e", ")", ";", "}", "}" ]

[ "Decode", "lz", "to", "string", "string", "." ]

[ "public", "static", "void", "putAt", "(", "BitSet", "self", ",", "IntRange", "range", ",", "boolean", "value", ")", "{", "RangeInfo", "info", "=", "subListBorders", "(", "self", ".", "length", "(", ")", ",", "range", ")", ";", "self", ".", "set", "(", "info", ".", "from", ",", "info", ".", "to", ",", "value", ")", ";", "}" ]

[ "Support", "assigning", "a", "range", "of", "values", "with", "a", "single", "assignment", "statement", "." ]

[ "private", "void", "addGalleryEntries", "(", "CmsGalleryTreeItem", "parent", ",", "List", "<", "CmsGalleryFolderEntry", ">", "galleries", ")", "{", "for", "(", "CmsGalleryFolderEntry", "galleryFolder", ":", "galleries", ")", "{", "CmsGalleryTreeItem", "folderItem", "=", "createGalleryFolderItem", "(", "galleryFolder", ")", ";", "parent", ".", "addChild", "(", "folderItem", ")", ";", "m_galleryTreeItems", ".", "put", "(", "galleryFolder", ".", "getStructureId", "(", ")", ",", "folderItem", ")", ";", "addGalleryEntries", "(", "folderItem", ",", "galleryFolder", ".", "getSubGalleries", "(", ")", ")", ";", "}", "}" ]

[ "Adds", "the", "gallery", "tree", "items", "to", "the", "parent", ".", "<p", ">" ]

[ "public", "final", "Group", "createGroup", "(", "ProjectName", "name", ",", "Group", "group", ")", "{", "CreateGroupRequest", "request", "=", "CreateGroupRequest", ".", "newBuilder", "(", ")", ".", "setName", "(", "name", "==", "null", "?", "null", ":", "name", ".", "toString", "(", ")", ")", ".", "setGroup", "(", "group", ")", ".", "build", "(", ")", ";", "return", "createGroup", "(", "request", ")", ";", "}" ]

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

[ "public", "static", "QRCode", "tryParse", "(", "String", "hhd", ",", "String", "msg", ")", "{", "try", "{", "return", "new", "QRCode", "(", "hhd", ",", "msg", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "return", "null", ";", "}", "}" ]

[ "Versucht", "die", "Daten", "als", "QR", "-", "Code", "zu", "parsen", "." ]

[ "public", "static", "long", "mixTimeSpanAndPointInTime", "(", "long", "loadTime", ",", "long", "refreshAfter", ",", "long", "pointInTime", ")", "{", "long", "_refreshTime", "=", "loadTime", "+", "refreshAfter", ";", "if", "(", "_refreshTime", "<", "0", ")", "{", "_refreshTime", "=", "ETERNAL", ";", "}", "if", "(", "pointInTime", "==", "ETERNAL", ")", "{", "return", "_refreshTime", ";", "}", "if", "(", "pointInTime", ">", "_refreshTime", ")", "{", "return", "_refreshTime", ";", "}", "long", "_absPointInTime", "=", "Math", ".", "abs", "(", "pointInTime", ")", ";", "if", "(", "_absPointInTime", "<=", "_refreshTime", ")", "{", "return", "pointInTime", ";", "}", "long", "_pointInTimeMinusDelta", "=", "_absPointInTime", "-", "refreshAfter", ";", "if", "(", "_pointInTimeMinusDelta", "<", "_refreshTime", ")", "{", "return", "_pointInTimeMinusDelta", ";", "}", "return", "_refreshTime", ";", "}" ]

[ "Combine", "a", "refresh", "time", "span", "and", "an", "expiry", "at", "a", "specified", "point", "in", "time", "." ]

[ "public", "void", "modifiedService", "(", "ServiceReference", "<", "FilterFactory", ">", "reference", ",", "FilterFactoryReference", "service", ")", "{", "if", "(", "service", "!=", "null", ")", "{", "service", ".", "setProperties", "(", "reference", ")", ";", "LOGGER", ".", "debug", "(", "\"updated FilterFactory {} for application {}\"", ",", "service", ".", "getFactory", "(", ")", ".", "getClass", "(", ")", ".", "getName", "(", ")", ",", "applicationName", ")", ";", "}", "}" ]

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

[ "public", "static", "InputStream", "getResourceAsStream", "(", "String", "name", ")", "{", "Params", ".", "notNullOrEmpty", "(", "name", ",", "\"Resource name\"", ")", ";", "// not documented behavior: accept but ignore trailing path separator\r", "if", "(", "name", ".", "charAt", "(", "0", ")", "==", "'", "'", ")", "{", "name", "=", "name", ".", "substring", "(", "1", ")", ";", "}", "InputStream", "stream", "=", "getResourceAsStream", "(", "name", ",", "new", "ClassLoader", "[", "]", "{", "Thread", ".", "currentThread", "(", ")", ".", "getContextClassLoader", "(", ")", ",", "Classes", ".", "class", ".", "getClassLoader", "(", ")", ",", "ClassLoader", ".", "getSystemClassLoader", "(", ")", "}", ")", ";", "if", "(", "stream", "==", "null", ")", "{", "throw", "new", "NoSuchBeingException", "(", "\"Resource |%s| not found.\"", ",", "name", ")", ";", "}", "return", "stream", ";", "}" ]

[ "Retrieve", "resource", "identified", "by", "qualified", "name", "as", "input", "stream", ".", "This", "method", "does", "its", "best", "to", "load", "requested", "resource", "but", "throws", "exception", "if", "fail", ".", "Resource", "is", "loaded", "using", "{", "@link", "ClassLoader#getResourceAsStream", "(", "String", ")", "}", "and", "<code", ">", "name<", "/", "code", ">", "argument", "should", "follow", "Java", "class", "loader", "convention", ":", "it", "is", "always", "considered", "as", "absolute", "path", "that", "is", "should", "contain", "package", "but", "does", "not", "start", "with", "leading", "path", "separator", "e", ".", "g", ".", "<code", ">", "js", "/", "fop", "/", "config", ".", "xml<", "/", "code", ">", ".", "<p", ">", "Resource", "is", "searched", "into", "next", "class", "loaders", "in", "given", "order", ":", "<ul", ">", "<li", ">", "current", "thread", "context", "class", "loader", "<li", ">", "this", "utility", "class", "loader", "<li", ">", "system", "class", "loader", "as", "returned", "by", "{", "@link", "ClassLoader#getSystemClassLoader", "()", "}", "<", "/", "ul", ">" ]

[ "public", "PreparedStatement", "getPreparedStatement", "(", "Connection", "con", ",", "CmsUUID", "projectId", ",", "String", "queryKey", ")", "throws", "SQLException", "{", "String", "rawSql", "=", "readQuery", "(", "projectId", ",", "queryKey", ")", ";", "return", "getPreparedStatementForSql", "(", "con", ",", "rawSql", ")", ";", "}" ]

[ "Returns", "a", "PreparedStatement", "for", "a", "JDBC", "connection", "specified", "by", "the", "key", "of", "a", "SQL", "query", "and", "the", "project", "-", "ID", ".", "<p", ">" ]

[ "private", "int", "getNextAvailDirInTier", "(", "StorageTierView", "tierView", ",", "long", "blockSize", ")", "{", "int", "dirViewIndex", "=", "mTierAliasToLastDirMap", ".", "get", "(", "tierView", ".", "getTierViewAlias", "(", ")", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "tierView", ".", "getDirViews", "(", ")", ".", "size", "(", ")", ";", "i", "++", ")", "{", "// try this many times", "dirViewIndex", "=", "(", "dirViewIndex", "+", "1", ")", "%", "tierView", ".", "getDirViews", "(", ")", ".", "size", "(", ")", ";", "if", "(", "tierView", ".", "getDirView", "(", "dirViewIndex", ")", ".", "getAvailableBytes", "(", ")", ">=", "blockSize", ")", "{", "return", "dirViewIndex", ";", "}", "}", "return", "-", "1", ";", "}" ]

[ "Finds", "an", "available", "dir", "in", "a", "given", "tier", "for", "a", "block", "with", "blockSize", "." ]

[ "public", "static", "void", "verifyRolloutGroupParameter", "(", "final", "int", "amountGroup", ",", "final", "QuotaManagement", "quotaManagement", ")", "{", "if", "(", "amountGroup", "<=", "0", ")", "{", "throw", "new", "ValidationException", "(", "\"The amount of groups cannot be lower than zero\"", ")", ";", "}", "else", "if", "(", "amountGroup", ">", "quotaManagement", ".", "getMaxRolloutGroupsPerRollout", "(", ")", ")", "{", "throw", "new", "QuotaExceededException", "(", "\"The amount of groups cannot be greater than \"", "+", "quotaManagement", ".", "getMaxRolloutGroupsPerRollout", "(", ")", ")", ";", "}", "}" ]

[ "Verify", "if", "the", "supplied", "amount", "of", "groups", "is", "in", "range" ]

[ "public", "int", "executeToDestination", "(", "final", "String", "pointerStr", ",", "final", "Source", "source", ",", "final", "Destination", "destination", ")", "throws", "XPointerException", "{", "final", "Pointer", "pointer", "=", "getPointer", "(", "pointerStr", ")", ";", "final", "XdmNode", "node", "=", "processor", ".", "newDocumentBuilder", "(", ")", ".", "wrap", "(", "source", ")", ";", "if", "(", "pointer", "!=", "null", ")", "{", "if", "(", "pointer", ".", "isShortHandPresent", "(", ")", ")", "{", "return", "executeShorthandPointer", "(", "pointer", ".", "getShortHand", "(", ")", ",", "node", ",", "destination", ")", ";", "}", "else", "if", "(", "pointer", ".", "isSchemeBased", "(", ")", ")", "{", "return", "executeSchemaPointer", "(", "pointer", ",", "node", ",", "destination", ")", ";", "}", "else", "{", "throw", "new", "XPointerResourceException", "(", "\"Unknown pointer expression\"", ")", ";", "}", "}", "else", "{", "throw", "new", "XPointerResourceException", "(", "\"Unknown pointer expression\"", ")", ";", "}", "}" ]

[ "Execute", "a", "xpointer", "expression", "on", "a", "xml", "source", ".", "The", "result", "is", "send", "to", "a", "Saxon", "{", "@link", "net", ".", "sf", ".", "saxon", ".", "s9api", ".", "Destination", "}" ]

[ "private", "Route", "getRoute", "(", "String", "httpMethod", ",", "String", "path", ")", "{", "Preconditions", ".", "notEmpty", "(", "httpMethod", ",", "\"no httpMethod provided.\"", ")", ";", "Preconditions", ".", "notNull", "(", "path", ",", "\"no path provided.\"", ")", ";", "String", "cleanPath", "=", "parsePath", "(", "path", ")", ";", "for", "(", "Route", "route", ":", "routes", ")", "{", "if", "(", "matchesPath", "(", "route", ".", "getPath", "(", ")", ",", "cleanPath", ")", "&&", "route", ".", "getHttpMethod", "(", ")", ".", "toString", "(", ")", ".", "equalsIgnoreCase", "(", "httpMethod", ")", ")", "{", "return", "route", ";", "}", "}", "return", "null", ";", "}" ]

[ "Retrieves", "the", "{", "@link", "Route", "}", "that", "matches", "the", "specified", "<code", ">", "httpMethod<", "/", "code", ">", "and", "<code", ">", "path<", "/", "code", ">", "." ]

[ "public", "void", "loadAccessors", "(", "Class", "<", "?", ">", "targetClass", ",", "MappedField", "configuredField", ",", "MappedField", "targetField", ")", "{", "// First checks xml configuration\r", "xml", ".", "fillMappedField", "(", "configuredClass", ",", "configuredField", ")", ".", "fillMappedField", "(", "targetClass", ",", "targetField", ")", "// fill target field with custom methods defined in the configured field\r", ".", "fillOppositeField", "(", "configuredClass", ",", "configuredField", ",", "targetField", ")", ";", "// If no present custom methods in XML, it checks annotations\r", "Annotation", ".", "fillMappedField", "(", "configuredClass", ",", "configuredField", ")", ";", "Annotation", ".", "fillMappedField", "(", "targetClass", ",", "targetField", ")", ";", "// fill target field with custom methods defined in the configured field\r", "Annotation", ".", "fillOppositeField", "(", "configuredClass", ",", "configuredField", ",", "targetField", ")", ";", "}" ]

[ "Fill", "fields", "with", "they", "custom", "methods", "." ]

[ "void", "updateAgentConfigurationFile", "(", "TargetHandlerParameters", "parameters", ",", "SSHClient", "ssh", ",", "File", "tmpDir", ",", "Map", "<", "String", ",", "String", ">", "keyToNewValue", ")", "throws", "IOException", "{", "this", ".", "logger", ".", "fine", "(", "\"Updating agent parameters on remote host...\"", ")", ";", "// Update the agent's configuration file", "String", "agentConfigDir", "=", "Utils", ".", "getValue", "(", "parameters", ".", "getTargetProperties", "(", ")", ",", "SCP_AGENT_CONFIG_DIR", ",", "DEFAULT_SCP_AGENT_CONFIG_DIR", ")", ";", "File", "localAgentConfig", "=", "new", "File", "(", "tmpDir", ",", "Constants", ".", "KARAF_CFG_FILE_AGENT", ")", ";", "File", "remoteAgentConfig", "=", "new", "File", "(", "agentConfigDir", ",", "Constants", ".", "KARAF_CFG_FILE_AGENT", ")", ";", "// Download remote agent config file...", "ssh", ".", "newSCPFileTransfer", "(", ")", ".", "download", "(", "remoteAgentConfig", ".", "getCanonicalPath", "(", ")", ",", "new", "FileSystemFile", "(", "tmpDir", ")", ")", ";", "// Replace \"parameters\" property to point on the user data file...", "String", "config", "=", "Utils", ".", "readFileContent", "(", "localAgentConfig", ")", ";", "config", "=", "Utils", ".", "updateProperties", "(", "config", ",", "keyToNewValue", ")", ";", "Utils", ".", "writeStringInto", "(", "config", ",", "localAgentConfig", ")", ";", "// Then upload agent config file back", "ssh", ".", "newSCPFileTransfer", "(", ")", ".", "upload", "(", "new", "FileSystemFile", "(", "localAgentConfig", ")", ",", "agentConfigDir", ")", ";", "}" ]

[ "Updates", "the", "configuration", "file", "of", "an", "agent", "." ]

[ "private", "void", "writeControlFile", "(", "FileSystem", "fs", ",", "Path", "outputPath", ",", "Path", "checksumFile", ",", "String", "name", ")", "throws", "IOException", "{", "SequenceFile", ".", "Writer", "write", "=", "null", ";", "try", "{", "Path", "parentDir", "=", "new", "Path", "(", "rtc", ".", "input", ",", "\"filelists\"", ")", ";", "if", "(", "!", "fs", ".", "exists", "(", "parentDir", ")", ")", "{", "fs", ".", "mkdirs", "(", "parentDir", ")", ";", "}", "Path", "controlFile", "=", "new", "Path", "(", "parentDir", ",", "name", ")", ";", "write", "=", "SequenceFile", ".", "createWriter", "(", "fs", ",", "fs", ".", "getConf", "(", ")", ",", "controlFile", ",", "Text", ".", "class", ",", "Text", ".", "class", ",", "CompressionType", ".", "NONE", ")", ";", "write", ".", "append", "(", "new", "Text", "(", "outputPath", ".", "toString", "(", ")", ")", ",", "new", "Text", "(", "checksumFile", ".", "toString", "(", ")", ")", ")", ";", "}", "finally", "{", "if", "(", "write", "!=", "null", ")", "write", ".", "close", "(", ")", ";", "write", "=", "null", ";", "}", "}" ]

[ "This", "is", "used", "for", "verification", "Each", "mapper", "writes", "one", "control", "file", "control", "file", "only", "contains", "the", "base", "directory", "written", "by", "this", "mapper", "and", "the", "checksum", "file", "path", "so", "that", "we", "could", "create", "a", "Read", "mapper", "which", "scanned", "the", "files", "under", "the", "base", "directory", "and", "verify", "the", "checksum", "of", "files", "with", "the", "information", "given", "in", "the", "checksum", "file", "." ]

[ "static", "String", "buildSelectChunkSql", "(", "String", "databaseType", ",", "String", "table", ",", "long", "start", ",", "int", "length", ",", "String", "columns", ",", "String", "[", "]", "columnNames", ")", "{", "String", "sqlText", "=", "\"SELECT \"", "+", "columns", "+", "\" FROM \"", "+", "table", ";", "switch", "(", "databaseType", ")", "{", "case", "SQL_SERVER_DB_TYPE", ":", "// requires ORDER BY clause with OFFSET/FETCH NEXT clauses, syntax supported since SQLServer 2012", "sqlText", "+=", "\" ORDER BY ROW_NUMBER() OVER (ORDER BY (SELECT 0))\"", ";", "sqlText", "+=", "\" OFFSET \"", "+", "start", "+", "\" ROWS FETCH NEXT \"", "+", "length", "+", "\" ROWS ONLY\"", ";", "break", ";", "case", "ORACLE_DB_TYPE", ":", "sqlText", "+=", "\" OFFSET \"", "+", "start", "+", "\" ROWS FETCH NEXT \"", "+", "length", "+", "\" ROWS ONLY\"", ";", "break", ";", "case", "TERADATA_DB_TYPE", ":", "sqlText", "+=", "\" QUALIFY ROW_NUMBER() OVER (ORDER BY \"", "+", "columnNames", "[", "0", "]", "+", "\") BETWEEN \"", "+", "(", "start", "+", "1", ")", "+", "\" AND \"", "+", "(", "start", "+", "length", ")", ";", "break", ";", "default", ":", "sqlText", "+=", "\" LIMIT \"", "+", "length", "+", "\" OFFSET \"", "+", "start", ";", "}", "return", "sqlText", ";", "}" ]

[ "Builds", "SQL", "SELECT", "to", "retrieve", "chunk", "of", "rows", "from", "a", "table", "based", "on", "row", "offset", "and", "number", "of", "rows", "in", "a", "chunk", "." ]

[ "public", "static", "Quaternionfc", "nlerpIterative", "(", "Quaternionf", "[", "]", "qs", ",", "float", "[", "]", "weights", ",", "float", "dotThreshold", ",", "Quaternionf", "dest", ")", "{", "dest", ".", "set", "(", "qs", "[", "0", "]", ")", ";", "float", "w", "=", "weights", "[", "0", "]", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<", "qs", ".", "length", ";", "i", "++", ")", "{", "float", "w0", "=", "w", ";", "float", "w1", "=", "weights", "[", "i", "]", ";", "float", "rw1", "=", "w1", "/", "(", "w0", "+", "w1", ")", ";", "w", "+=", "w1", ";", "dest", ".", "nlerpIterative", "(", "qs", "[", "i", "]", ",", "rw1", ",", "dotThreshold", ")", ";", "}", "return", "dest", ";", "}" ]

[ "Interpolate", "between", "all", "of", "the", "quaternions", "given", "in", "<code", ">", "qs<", "/", "code", ">", "via", "iterative", "non", "-", "spherical", "linear", "interpolation", "using", "the", "specified", "interpolation", "factors", "<code", ">", "weights<", "/", "code", ">", "and", "store", "the", "result", "in", "<code", ">", "dest<", "/", "code", ">", ".", "<p", ">", "This", "method", "will", "interpolate", "between", "each", "two", "successive", "quaternions", "via", "{", "@link", "#nlerpIterative", "(", "Quaternionfc", "float", "float", ")", "}", "using", "their", "relative", "interpolation", "weights", ".", "<p", ">", "Reference", ":", "<a", "href", "=", "http", ":", "//", "gamedev", ".", "stackexchange", ".", "com", "/", "questions", "/", "62354", "/", "method", "-", "for", "-", "interpolation", "-", "between", "-", "3", "-", "quaternions#answer", "-", "62356", ">", "http", ":", "//", "gamedev", ".", "stackexchange", ".", "com", "/", "<", "/", "a", ">" ]

[ "static", "public", "File", "computeBinDir", "(", "File", "installDir", ")", "{", "if", "(", "null", "!=", "installDir", ")", "{", "// Command-line package", "File", "binDir", "=", "new", "File", "(", "installDir", ",", "\"bin\"", ")", ";", "if", "(", "binDir", ".", "exists", "(", ")", "&&", "binDir", ".", "isDirectory", "(", ")", ")", "{", "return", "binDir", ";", "}", "// Development environment", "File", "nunaliit2Dir", "=", "computeNunaliitDir", "(", "installDir", ")", ";", "binDir", "=", "new", "File", "(", "nunaliit2Dir", ",", "\"nunaliit2-couch-sdk/target/appassembler/bin\"", ")", ";", "if", "(", "binDir", ".", "exists", "(", ")", "&&", "binDir", ".", "isDirectory", "(", ")", ")", "{", "return", "binDir", ";", "}", "}", "return", "null", ";", "}" ]

[ "Finds", "the", "bin", "directory", "from", "the", "installation", "location", "and", "returns", "it", ".", "If", "the", "command", "-", "line", "tool", "is", "packaged", "and", "deployed", "then", "the", "bin", "directory", "is", "found", "at", "the", "root", "of", "the", "installation", ".", "If", "the", "command", "-", "line", "tool", "is", "run", "from", "the", "development", "environment", "then", "the", "bin", "directory", "is", "found", "in", "the", "SDK", "sub", "-", "project", "." ]

[ "public", "static", "Cluster", "getOrCreateCluster", "(", "String", "clusterName", ",", "CassandraHostConfigurator", "cassandraHostConfigurator", ")", "{", "return", "createCluster", "(", "clusterName", ",", "cassandraHostConfigurator", ",", "null", ")", ";", "}" ]

[ "Calls", "the", "three", "argument", "version", "with", "a", "null", "credentials", "map", ".", "{" ]

[ "private", "void", "showEndAnimation", "(", "Command", "callback", ",", "int", "top", ",", "int", "left", ",", "boolean", "isDrop", ")", "{", "if", "(", "!", "isAnimationEnabled", "(", ")", "||", "(", "m_dragHelper", "==", "null", ")", ")", "{", "callback", ".", "execute", "(", ")", ";", "return", ";", "}", "switch", "(", "m_animationType", ")", "{", "case", "SPECIAL", ":", "List", "<", "Element", ">", "overlays", "=", "CmsDomUtil", ".", "getElementsByClass", "(", "I_CmsLayoutBundle", ".", "INSTANCE", ".", "generalCss", "(", ")", ".", "disablingOverlay", "(", ")", ",", "m_draggable", ".", "getElement", "(", ")", ")", ";", "Element", "overlay", "=", "overlays", ".", "size", "(", ")", ">", "0", "?", "overlays", ".", "get", "(", "0", ")", ":", "null", ";", "m_currentAnimation", "=", "new", "SpecialAnimation", "(", "m_dragHelper", ",", "m_draggable", ".", "getElement", "(", ")", ",", "overlay", ",", "callback", ",", "isDrop", ")", ";", "break", ";", "case", "MOVE", ":", "Element", "parentElement", "=", "m_dragHelper", ".", "getParentElement", "(", ")", ";", "int", "endTop", "=", "top", "-", "parentElement", ".", "getAbsoluteTop", "(", ")", ";", "int", "endLeft", "=", "left", "-", "parentElement", ".", "getAbsoluteLeft", "(", ")", ";", "int", "startTop", "=", "CmsDomUtil", ".", "getCurrentStyleInt", "(", "m_dragHelper", ",", "Style", ".", "top", ")", ";", "int", "startLeft", "=", "CmsDomUtil", ".", "getCurrentStyleInt", "(", "m_dragHelper", ",", "Style", ".", "left", ")", ";", "m_currentAnimation", "=", "new", "CmsMoveAnimation", "(", "m_dragHelper", ",", "startTop", ",", "startLeft", ",", "endTop", ",", "endLeft", ",", "callback", ")", ";", "break", ";", "default", ":", "// nothing to do", "}", "m_currentAnimation", ".", "run", "(", "400", ")", ";", "}" ]

[ "Shows", "the", "end", "animation", "on", "drop", "or", "cancel", ".", "Executes", "the", "given", "callback", "afterwards", ".", "<p", ">" ]

[ "private", "boolean", "isNotEnabled", "(", "String", "action", ",", "String", "expected", ",", "String", "extra", ")", "{", "// wait for element to be displayed", "if", "(", "!", "is", ".", "enabled", "(", ")", ")", "{", "waitForState", ".", "enabled", "(", ")", ";", "}", "if", "(", "!", "is", ".", "enabled", "(", ")", ")", "{", "reporter", ".", "fail", "(", "action", ",", "expected", ",", "extra", "+", "prettyOutput", "(", ")", "+", "NOT_ENABLED", ")", ";", "// indicates element not enabled", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Determines", "if", "the", "element", "is", "displayed", ".", "If", "it", "isn", "t", "it", "ll", "wait", "up", "to", "the", "default", "time", "(", "5", "seconds", ")", "for", "the", "element", "to", "be", "displayed" ]

[ "public", "boolean", "pushNamespace", "(", "String", "prefix", ",", "String", "uri", ",", "int", "elemDepth", ")", "{", "// Prefixes \"xml\" and \"xmlns\" cannot be redefined", "if", "(", "prefix", ".", "startsWith", "(", "XML_PREFIX", ")", ")", "{", "return", "false", ";", "}", "Stack", "stack", ";", "// Get the stack that contains URIs for the specified prefix", "if", "(", "(", "stack", "=", "(", "Stack", ")", "m_namespaces", ".", "get", "(", "prefix", ")", ")", "==", "null", ")", "{", "m_namespaces", ".", "put", "(", "prefix", ",", "stack", "=", "new", "Stack", "(", ")", ")", ";", "}", "if", "(", "!", "stack", ".", "empty", "(", ")", ")", "{", "MappingRecord", "mr", "=", "(", "MappingRecord", ")", "stack", ".", "peek", "(", ")", ";", "if", "(", "uri", ".", "equals", "(", "mr", ".", "m_uri", ")", "||", "elemDepth", "==", "mr", ".", "m_declarationDepth", ")", "{", "// If the same prefix/uri mapping is already on the stack", "// don't push this one.", "// Or if we have a mapping at the same depth", "// don't replace by pushing this one.", "return", "false", ";", "}", "}", "MappingRecord", "map", "=", "new", "MappingRecord", "(", "prefix", ",", "uri", ",", "elemDepth", ")", ";", "stack", ".", "push", "(", "map", ")", ";", "m_nodeStack", ".", "push", "(", "map", ")", ";", "return", "true", ";", "}" ]

[ "Declare", "a", "mapping", "of", "a", "prefix", "to", "namespace", "URI", "at", "the", "given", "element", "depth", "." ]

[ "public", "String", "randomLowerMaxLength", "(", "int", "minLength", ",", "int", "maxLength", ")", "{", "int", "range", "=", "maxLength", "-", "minLength", ";", "int", "randomLength", "=", "0", ";", "if", "(", "range", ">", "0", ")", "{", "randomLength", "=", "random", "(", "range", ")", ";", "}", "return", "randomLower", "(", "minLength", "+", "randomLength", ")", ";", "}" ]

[ "Creates", "a", "random", "string", "consisting", "of", "lowercase", "letters", "." ]

[ "public", "static", "BitmapTextureCallback", "wrapCallback", "(", "ResourceCache", "<", "GVRImage", ">", "cache", ",", "BitmapTextureCallback", "callback", ")", "{", "return", "new", "BitmapTextureCallbackWrapper", "(", "cache", ",", "callback", ")", ";", "}" ]

[ "Wrap", "the", "callback", "to", "cache", "the", "{" ]

[ "public", "static", "Object", "callGetterNormalizingStrings", "(", "View", "view", ",", "String", "methodName", ")", "{", "Object", "value", "=", "callGetter", "(", "view", ",", "methodName", ")", ";", "if", "(", "value", "instanceof", "CharSequence", ")", "{", "value", "=", "value", ".", "toString", "(", ")", ";", "}", "return", "value", ";", "}" ]

[ "Calls", "the", "given", "method", "by", "name", "on", "the", "given", "view", "assuming", "that", "it", "s", "a", "getter", "i", ".", "e", ".", "it", "doesn", "t", "have", "arguments", "." ]

[ "public", "Table", "withParameters", "(", "java", ".", "util", ".", "Map", "<", "String", ",", "String", ">", "parameters", ")", "{", "setParameters", "(", "parameters", ")", ";", "return", "this", ";", "}" ]

[ "<p", ">", "These", "key", "-", "value", "pairs", "define", "properties", "associated", "with", "the", "table", ".", "<", "/", "p", ">" ]