Datasets:

---

stojchet

/

base_prediction_dataset

like 0

[ "public", "final", "Timestamp", "addHour", "(", "int", "amount", ")", "{", "long", "delta", "=", "(", "long", ")", "amount", "*", "60", "*", "60", "*", "1000", ";", "return", "addMillisForPrecision", "(", "delta", ",", "Precision", ".", "MINUTE", ",", "false", ")", ";", "}" ]

[ "Returns", "a", "timestamp", "relative", "to", "this", "one", "by", "the", "given", "number", "of", "hours", ".", "<p", ">", "This", "method", "always", "returns", "a", "Timestamp", "with", "at", "least", "MINUTE", "precision", ".", "For", "example", "adding", "one", "hour", "to", "{", "@code", "2011T", "}", "results", "in", "{", "@code", "2011", "-", "01", "-", "01T01", ":", "00", "-", "00", ":", "00", "}", ".", "To", "receive", "a", "Timestamp", "that", "always", "maintains", "the", "same", "precision", "as", "the", "original", "use", "{", "@link", "#adjustHour", "(", "int", ")", "}", "." ]

[ "private", "static", "void", "walkFields", "(", "final", "Class", "<", "?", ">", "cls", ",", "final", "Map", "<", "String", ",", "Field", ">", "fieldMap", ")", "{", "if", "(", "cls", ".", "equals", "(", "Object", ".", "class", ")", ")", "{", "return", ";", "}", "Class", "<", "?", ">", "superClass", "=", "cls", ".", "getSuperclass", "(", ")", ";", "walkFields", "(", "superClass", ",", "fieldMap", ")", ";", "Arrays", ".", "stream", "(", "cls", ".", "getDeclaredFields", "(", ")", ")", ".", "filter", "(", "f", "->", "!", "Modifier", ".", "isStatic", "(", "f", ".", "getModifiers", "(", ")", ")", ")", ".", "forEach", "(", "f", "->", "fieldMap", ".", "put", "(", "f", ".", "getName", "(", ")", ",", "f", ")", ")", ";", "}" ]

[ "指定したクラスの持つ全てのフィールドを再帰的に探索して取得する" ]

[ "protected", "void", "removeRoute", "(", "int", "dpc", ",", "int", "opc", ",", "int", "si", ",", "String", "asName", ")", "throws", "Exception", "{", "AsImpl", "asImpl", "=", "null", ";", "for", "(", "FastList", ".", "Node", "<", "As", ">", "n", "=", "this", ".", "m3uaManagement", ".", "appServers", ".", "head", "(", ")", ",", "end", "=", "this", ".", "m3uaManagement", ".", "appServers", ".", "tail", "(", ")", ";", "(", "n", "=", "n", ".", "getNext", "(", ")", ")", "!=", "end", ";", ")", "{", "if", "(", "n", ".", "getValue", "(", ")", ".", "getName", "(", ")", ".", "compareTo", "(", "asName", ")", "==", "0", ")", "{", "asImpl", "=", "(", "AsImpl", ")", "n", ".", "getValue", "(", ")", ";", "break", ";", "}", "}", "if", "(", "asImpl", "==", "null", ")", "{", "throw", "new", "Exception", "(", "String", ".", "format", "(", "M3UAOAMMessages", ".", "NO_AS_FOUND", ",", "asName", ")", ")", ";", "}", "String", "key", "=", "(", "new", "StringBuffer", "(", ")", ".", "append", "(", "dpc", ")", ".", "append", "(", "KEY_SEPARATOR", ")", ".", "append", "(", "opc", ")", ".", "append", "(", "KEY_SEPARATOR", ")", ".", "append", "(", "si", ")", ")", ".", "toString", "(", ")", ";", "RouteAsImpl", "asArray", "=", "route", ".", "get", "(", "key", ")", ";", "if", "(", "asArray", "==", "null", ")", "{", "throw", "new", "Exception", "(", "String", ".", "format", "(", "\"No AS=%s configured for dpc=%d opc=%d si=%d\"", ",", "asImpl", ".", "getName", "(", ")", ",", "dpc", ",", "opc", ",", "si", ")", ")", ";", "}", "asArray", ".", "removeRoute", "(", "dpc", ",", "opc", ",", "si", ",", "asImpl", ")", ";", "this", ".", "removeAsFromDPC", "(", "dpc", ",", "asImpl", ")", ";", "//Final check to remove RouteAs", "if", "(", "!", "asArray", ".", "hasAs", "(", ")", ")", "{", "route", ".", "remove", "(", "key", ")", ";", "}", "this", ".", "m3uaManagement", ".", "store", "(", ")", ";", "}" ]

[ "Removes", "the", "{", "@link", "AsImpl", "}", "from", "key", "(", "combination", "of", "DPC", ":", "OPC", ":", "Si", ")" ]

[ "public", "static", "void", "consumeTPVObject", "(", "TPVObject", "tpv", ",", "Processor", "processor", ",", "GpsdEndpoint", "endpoint", ",", "ExceptionHandler", "exceptionHandler", ")", "{", "// Simplify logging when https://github.com/taimos/GPSd4Java/pull/19 is merged into upstream.", "LOG", ".", "debug", "(", "\"About to consume TPV object {},{} from {}\"", ",", "tpv", ".", "getLatitude", "(", ")", ",", "tpv", ".", "getLongitude", "(", ")", ",", "endpoint", ")", ";", "Validate", ".", "notNull", "(", "tpv", ")", ";", "Validate", ".", "notNull", "(", "processor", ")", ";", "Validate", ".", "notNull", "(", "endpoint", ")", ";", "GpsCoordinates", "coordinates", "=", "gpsCoordinates", "(", "new", "Date", "(", "new", "Double", "(", "tpv", ".", "getTimestamp", "(", ")", ")", ".", "longValue", "(", ")", ")", ",", "tpv", ".", "getLatitude", "(", ")", ",", "tpv", ".", "getLongitude", "(", ")", ")", ";", "Exchange", "exchange", "=", "anExchange", "(", "endpoint", ".", "getCamelContext", "(", ")", ")", ".", "withPattern", "(", "OutOnly", ")", ".", "withHeader", "(", "TPV_HEADER", ",", "tpv", ")", ".", "withBody", "(", "coordinates", ")", ".", "build", "(", ")", ";", "try", "{", "processor", ".", "process", "(", "exchange", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "exceptionHandler", ".", "handleException", "(", "e", ")", ";", "}", "}" ]

[ "Process", "the", "TPVObject", "all", "params", "required", "." ]

[ "private", "void", "ensureValidACLAuthorization", "(", "final", "FedoraResource", "resource", ",", "final", "Model", "inputModel", ")", "{", "if", "(", "resource", ".", "isAcl", "(", ")", ")", "{", "final", "Set", "<", "Node", ">", "uniqueAuthSubjects", "=", "new", "HashSet", "<>", "(", ")", ";", "inputModel", ".", "listStatements", "(", ")", ".", "forEachRemaining", "(", "(", "final", "Statement", "s", ")", "->", "{", "LOGGER", ".", "debug", "(", "\"statement: s={}, p={}, o={}\"", ",", "s", ".", "getSubject", "(", ")", ",", "s", ".", "getPredicate", "(", ")", ",", "s", ".", "getObject", "(", ")", ")", ";", "final", "Node", "subject", "=", "s", ".", "getSubject", "(", ")", ".", "asNode", "(", ")", ";", "// If subject is Authorization Hash Resource, add it to the map with its accessTo/accessToClass status.", "if", "(", "subject", ".", "toString", "(", ")", ".", "contains", "(", "\"/\"", "+", "FCR_ACL", "+", "\"#\"", ")", ")", "{", "uniqueAuthSubjects", ".", "add", "(", "subject", ")", ";", "}", "}", ")", ";", "final", "Graph", "graph", "=", "inputModel", ".", "getGraph", "(", ")", ";", "uniqueAuthSubjects", ".", "forEach", "(", "(", "final", "Node", "subject", ")", "->", "{", "if", "(", "graph", ".", "contains", "(", "subject", ",", "WEBAC_ACCESS_TO_URI", ",", "Node", ".", "ANY", ")", "&&", "graph", ".", "contains", "(", "subject", ",", "WEBAC_ACCESS_TO_CLASS_URI", ",", "Node", ".", "ANY", ")", ")", "{", "throw", "new", "ACLAuthorizationConstraintViolationException", "(", "MessageFormat", ".", "format", "(", "\"Using both accessTo and accessToClass within \"", "+", "\"a single Authorization is not allowed: {0}.\"", ",", "subject", ".", "toString", "(", ")", ".", "substring", "(", "subject", ".", "toString", "(", ")", ".", "lastIndexOf", "(", "\"#\"", ")", ")", ")", ")", ";", "}", "else", "if", "(", "!", "(", "graph", ".", "contains", "(", "subject", ",", "WEBAC_ACCESS_TO_URI", ",", "Node", ".", "ANY", ")", "||", "graph", ".", "contains", "(", "subject", ",", "WEBAC_ACCESS_TO_CLASS_URI", ",", "Node", ".", "ANY", ")", ")", ")", "{", "inputModel", ".", "add", "(", "createDefaultAccessToStatement", "(", "subject", ".", "toString", "(", ")", ")", ")", ";", "}", "}", ")", ";", "}", "}" ]

[ "This", "method", "does", "two", "things", ":", "-", "Throws", "an", "exception", "if", "an", "authorization", "has", "both", "accessTo", "and", "accessToClass", "-", "Adds", "a", "default", "accessTo", "target", "if", "an", "authorization", "has", "neither", "accessTo", "nor", "accessToClass" ]

[ "public", "void", "addParam", "(", "String", "name", ",", "String", "value", ",", "int", "type", ")", "{", "// Current size usually is equal to the position\r", "params", ".", "add", "(", "new", "NameValuePair", "(", "type", ",", "name", ",", "value", ",", "params", ".", "size", "(", ")", ")", ")", ";", "}" ]

[ "Support", "method", "to", "add", "a", "new", "param", "to", "this", "custom", "variant" ]

[ "public", "SDVariable", "eye", "(", "String", "name", ",", "int", "rows", ",", "int", "cols", ",", "DataType", "dataType", ",", "int", "...", "batchDimension", ")", "{", "SDVariable", "eye", "=", "new", "Eye", "(", "sd", ",", "rows", ",", "cols", ",", "dataType", ",", "batchDimension", ")", ".", "outputVariables", "(", ")", "[", "0", "]", ";", "return", "updateVariableNameAndReference", "(", "eye", ",", "name", ")", ";", "}" ]

[ "Generate", "an", "identity", "matrix", "with", "the", "specified", "number", "of", "rows", "and", "columns", "with", "optional", "leading", "dims<br", ">", "Example", ":", "<br", ">", "batchShape", ":", "[", "3", "3", "]", "<br", ">", "numRows", ":", "2<br", ">", "numCols", ":", "4<br", ">", "returns", "a", "tensor", "of", "shape", "(", "3", "3", "2", "4", ")", "that", "consists", "of", "3", "*", "3", "batches", "of", "(", "2", "4", ")", "-", "shaped", "identity", "matrices", ":", "<br", ">", "1", "0", "0", "0<br", ">", "0", "1", "0", "0<br", ">" ]

[ "private", "static", "TimeZone", "getCustomTimeZone", "(", "String", "id", ")", "{", "Matcher", "m", "=", "NoImagePreloadHolder", ".", "CUSTOM_ZONE_ID_PATTERN", ".", "matcher", "(", "id", ")", ";", "if", "(", "!", "m", ".", "matches", "(", ")", ")", "{", "return", "null", ";", "}", "int", "hour", ";", "int", "minute", "=", "0", ";", "try", "{", "hour", "=", "Integer", ".", "parseInt", "(", "m", ".", "group", "(", "1", ")", ")", ";", "if", "(", "m", ".", "group", "(", "3", ")", "!=", "null", ")", "{", "minute", "=", "Integer", ".", "parseInt", "(", "m", ".", "group", "(", "3", ")", ")", ";", "}", "}", "catch", "(", "NumberFormatException", "impossible", ")", "{", "throw", "new", "AssertionError", "(", "impossible", ")", ";", "}", "if", "(", "hour", "<", "0", "||", "hour", ">", "23", "||", "minute", "<", "0", "||", "minute", ">", "59", ")", "{", "return", "null", ";", "}", "char", "sign", "=", "id", ".", "charAt", "(", "3", ")", ";", "int", "raw", "=", "(", "hour", "*", "3600000", ")", "+", "(", "minute", "*", "60000", ")", ";", "if", "(", "sign", "==", "'", "'", ")", "{", "raw", "=", "-", "raw", ";", "}", "String", "cleanId", "=", "String", ".", "format", "(", "Locale", ".", "ROOT", ",", "\"GMT%c%02d:%02d\"", ",", "sign", ",", "hour", ",", "minute", ")", ";", "return", "new", "SimpleTimeZone", "(", "raw", ",", "cleanId", ")", ";", "}" ]

[ "Returns", "a", "new", "SimpleTimeZone", "for", "an", "ID", "of", "the", "form", "GMT", "[", "+", "|", "-", "]", "hh", "[[", ":", "]", "mm", "]", "or", "null", "." ]

[ "public", "static", "int", "getRawRdw", "(", "byte", "[", "]", "hostData", ",", "int", "start", ",", "int", "length", ")", "{", "if", "(", "length", "-", "start", "<", "RDW_LEN", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Not enough bytes for an RDW\"", ")", ";", "}", "ByteBuffer", "buf", "=", "ByteBuffer", ".", "allocate", "(", "RDW_LEN", ")", ";", "buf", ".", "put", "(", "0", ",", "(", "byte", ")", "0", ")", ";", "buf", ".", "put", "(", "1", ",", "(", "byte", ")", "0", ")", ";", "buf", ".", "put", "(", "2", ",", "hostData", "[", "start", "+", "0", "]", ")", ";", "buf", ".", "put", "(", "3", ",", "hostData", "[", "start", "+", "1", "]", ")", ";", "return", "buf", ".", "getInt", "(", ")", ";", "}" ]

[ "RDW", "is", "a", "4", "bytes", "numeric", "where", "the", "first", "2", "bytes", "are", "the", "length", "of", "the", "record", "(", "LL", ")", "including", "the", "4", "byte", "RDW", "." ]

[ "public", "static", "byte", "[", "]", "computeHash", "(", "File", "file", ",", "MessageDigest", "digest", ",", "long", "from", ",", "long", "until", ")", "throws", "IOException", "{", "Preconditions", ".", "checkArgument", "(", "from", ">=", "0", ",", "\"negative offset\"", ")", ";", "Preconditions", ".", "checkArgument", "(", "until", ">", "from", ",", "\"end offset is smaller or equal to start offset\"", ")", ";", "Preconditions", ".", "checkArgument", "(", "until", "<=", "file", ".", "length", "(", ")", ",", "\"end offset is greater than file length\"", ")", ";", "try", "(", "RandomAccessFile", "raf", "=", "new", "RandomAccessFile", "(", "file", ",", "\"r\"", ")", ")", "{", "byte", "[", "]", "buffer", "=", "new", "byte", "[", "BUFFER_SIZE", "]", ";", "int", "readbytes", ";", "long", "byteSum", "=", "from", ";", "raf", ".", "seek", "(", "from", ")", ";", "while", "(", "(", "readbytes", "=", "raf", ".", "read", "(", "buffer", ")", ")", "!=", "-", "1", "&&", "byteSum", "<=", "until", ")", "{", "byteSum", "+=", "readbytes", ";", "if", "(", "byteSum", ">", "until", ")", "{", "readbytes", "-=", "(", "byteSum", "-", "until", ")", ";", "}", "digest", ".", "update", "(", "buffer", ",", "0", ",", "readbytes", ")", ";", "}", "return", "digest", ".", "digest", "(", ")", ";", "}", "}" ]

[ "Computes", "the", "hash", "value", "for", "the", "file", "bytes", "from", "offset", "<code", ">", "from<", "/", "code", ">", "until", "offset", "<code", ">", "until<", "/", "code", ">", "using", "the", "hash", "instance", "as", "defined", "by", "the", "hash", "type", "." ]

[ "public", "DataSlice", "getAssembledContent", "(", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "JmfTr", ".", "entry", "(", "this", ",", "tc", ",", "\"getAssembledContent\"", ")", ";", "DataSlice", "result", "=", "null", ";", "// lock the message - we don't want someone clearing the contents while we're doing this", "synchronized", "(", "getMessageLockArtefact", "(", ")", ")", "{", "// If contents isn't null, the message is assembled so we can return something useful", "if", "(", "contents", "!=", "null", ")", "{", "// We must mark the contents as shared now we're handing them out", "sharedContents", "=", "true", ";", "// d348294.1", "result", "=", "new", "DataSlice", "(", "contents", ",", "messageOffset", ",", "length", ")", ";", "}", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "JmfTr", ".", "exit", "(", "this", ",", "tc", ",", "\"getAssembledContent\"", ",", "result", ")", ";", "return", "result", ";", "}" ]

[ "Locking", ":", "Requires", "the", "lock", "as", "it", "relies", "on", "and", "may", "change", "vital", "instance", "variable", "(", "s", ")", "." ]

[ "protected", "DoubleMatrix1D", "gradSum", "(", "double", "t", ",", "DoubleMatrix1D", "fiX", ")", "{", "DoubleMatrix1D", "gradSum", "=", "F1", ".", "make", "(", "getDim", "(", ")", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "dim", ";", "i", "++", ")", "{", "double", "d", "=", "0", ";", "d", "+=", "1.", "/", "(", "t", "*", "fiX", ".", "getQuick", "(", "i", ")", ")", ";", "d", "+=", "-", "1.", "/", "(", "t", "*", "fiX", ".", "getQuick", "(", "getDim", "(", ")", "+", "i", ")", ")", ";", "gradSum", ".", "setQuick", "(", "i", ",", "d", ")", ";", "}", "return", "gradSum", ";", "}" ]

[ "Calculates", "the", "second", "term", "of", "the", "first", "row", "of", "(", "11", ".", "55", ")", "Convex", "Optimization", "." ]

[ "@", "Deprecated", "public", "static", "BoundingBox", "fromCoordinates", "(", "@", "FloatRange", "(", "from", "=", "MIN_LONGITUDE", ",", "to", "=", "GeoJsonConstants", ".", "MAX_LONGITUDE", ")", "double", "west", ",", "@", "FloatRange", "(", "from", "=", "MIN_LATITUDE", ",", "to", "=", "GeoJsonConstants", ".", "MAX_LATITUDE", ")", "double", "south", ",", "@", "FloatRange", "(", "from", "=", "MIN_LONGITUDE", ",", "to", "=", "GeoJsonConstants", ".", "MAX_LONGITUDE", ")", "double", "east", ",", "@", "FloatRange", "(", "from", "=", "MIN_LATITUDE", ",", "to", "=", "GeoJsonConstants", ".", "MAX_LATITUDE", ")", "double", "north", ")", "{", "return", "fromLngLats", "(", "west", ",", "south", ",", "east", ",", "north", ")", ";", "}" ]

[ "Define", "a", "new", "instance", "of", "this", "class", "by", "passing", "in", "four", "coordinates", "in", "the", "same", "order", "they", "would", "appear", "in", "the", "serialized", "GeoJson", "form", ".", "Limits", "are", "placed", "on", "the", "minimum", "and", "maximum", "coordinate", "values", "which", "can", "exist", "and", "comply", "with", "the", "GeoJson", "spec", "." ]

[ "public", "double", "similarityToLabel", "(", "LabelledDocument", "document", ",", "String", "label", ")", "{", "if", "(", "document", ".", "getReferencedContent", "(", ")", "!=", "null", ")", "{", "return", "similarityToLabel", "(", "document", ".", "getReferencedContent", "(", ")", ",", "label", ")", ";", "}", "else", "return", "similarityToLabel", "(", "document", ".", "getContent", "(", ")", ",", "label", ")", ";", "}" ]

[ "This", "method", "returns", "similarity", "of", "the", "document", "to", "specific", "label", "based", "on", "mean", "value" ]

[ "public", "static", "Builder", "from", "(", "Path", "swaggerPath", ")", "{", "Validate", ".", "notNull", "(", "swaggerPath", ",", "\"swaggerPath must not be null\"", ")", ";", "if", "(", "Files", ".", "notExists", "(", "swaggerPath", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "String", ".", "format", "(", "\"swaggerPath does not exist: %s\"", ",", "swaggerPath", ")", ")", ";", "}", "try", "{", "if", "(", "Files", ".", "isHidden", "(", "swaggerPath", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"swaggerPath must not be a hidden file\"", ")", ";", "}", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "new", "RuntimeException", "(", "\"Failed to check if swaggerPath is a hidden file\"", ",", "e", ")", ";", "}", "return", "new", "Builder", "(", "swaggerPath", ")", ";", "}" ]

[ "Creates", "a", "Swagger2MarkupConverter", ".", "Builder", "using", "a", "local", "Path", "." ]

[ "public", "static", "DiscountCurveInterface", "createDiscountCurveFromMonteCarloLiborModel", "(", "String", "forwardCurveName", ",", "LIBORModelMonteCarloSimulationModel", "model", ",", "double", "startTime", ")", "throws", "CalculationException", "{", "// Check if the LMM uses a discount curve which is created from a forward curve", "if", "(", "model", ".", "getModel", "(", ")", ".", "getDiscountCurve", "(", ")", "==", "null", "||", "model", ".", "getModel", "(", ")", ".", "getDiscountCurve", "(", ")", ".", "getName", "(", ")", ".", "toLowerCase", "(", ")", ".", "contains", "(", "\"DiscountCurveFromForwardCurve\"", ".", "toLowerCase", "(", ")", ")", ")", "{", "return", "new", "DiscountCurveFromForwardCurve", "(", "ForwardCurveInterpolation", ".", "createForwardCurveFromMonteCarloLiborModel", "(", "forwardCurveName", ",", "model", ",", "startTime", ")", ")", ";", "}", "else", "{", "// i.e. forward curve of Libor Model not OIS. In this case return the OIS curve.", "// Only at startTime 0!", "return", "(", "DiscountCurveInterface", ")", "model", ".", "getModel", "(", ")", ".", "getDiscountCurve", "(", ")", ";", "}", "}" ]

[ "Create", "a", "discount", "curve", "from", "forwards", "given", "by", "a", "LIBORMonteCarloModel", ".", "If", "the", "model", "uses", "multiple", "curves", "return", "its", "discount", "curve", "." ]

[ "public", "SelectQuery", "replaceDataset", "(", "@", "Nullable", "final", "Dataset", "dataset", ")", "{", "if", "(", "Objects", ".", "equal", "(", "this", ".", "dataset", ",", "dataset", ")", ")", "{", "return", "this", ";", "}", "else", "{", "try", "{", "return", "from", "(", "this", ".", "expression", ",", "dataset", ")", ";", "}", "catch", "(", "final", "ParseException", "ex", ")", "{", "throw", "new", "Error", "(", "\"Unexpected error - replacing dataset made the query invalid (!)\"", ",", "ex", ")", ";", "}", "}", "}" ]

[ "Replaces", "the", "dataset", "of", "this", "query", "with", "the", "one", "specified", "returning", "the", "resulting", "<tt", ">", "SelectQuery<", "/", "tt", ">", "object", "." ]

[ "private", "static", "void", "updateNode", "(", "Element", "parent", ",", "String", "nodeName", ",", "String", "value", ",", "boolean", "cdata", ")", "{", "// get current node element", "Element", "nodeElement", "=", "parent", ".", "element", "(", "nodeName", ")", ";", "if", "(", "value", "!=", "null", ")", "{", "if", "(", "nodeElement", "==", "null", ")", "{", "// element wasn't there before, add element and set value", "nodeElement", "=", "parent", ".", "addElement", "(", "nodeName", ")", ";", "}", "// element is there, update element value", "nodeElement", ".", "clearContent", "(", ")", ";", "if", "(", "cdata", ")", "{", "nodeElement", ".", "addCDATA", "(", "value", ")", ";", "}", "else", "{", "nodeElement", ".", "addText", "(", "value", ")", ";", "}", "}", "else", "{", "// remove only if element exists", "if", "(", "nodeElement", "!=", "null", ")", "{", "// remove element", "parent", ".", "remove", "(", "nodeElement", ")", ";", "}", "}", "}" ]

[ "Updates", "the", "given", "xml", "node", "with", "the", "given", "value", ".", "<p", ">" ]

[ "public", "void", "registerConnection", "(", "Connection", "connection", ",", "ConnectionDefinition", "connectionDefinition", ")", "{", "checkNotNull", "(", "connection", ")", ";", "checkNotNull", "(", "connectionDefinition", ")", ";", "if", "(", "this", ".", "connectionDefinitions", ".", "putIfAbsent", "(", "connectionDefinition", ".", "getName", "(", ")", ",", "connectionDefinition", ")", "!=", "null", ")", "{", "throw", "SeedException", ".", "createNew", "(", "JmsErrorCode", ".", "DUPLICATE_CONNECTION_NAME", ")", ".", "put", "(", "ERROR_CONNECTION_NAME", ",", "connectionDefinition", ".", "getName", "(", ")", ")", ";", "}", "if", "(", "this", ".", "connections", ".", "putIfAbsent", "(", "connectionDefinition", ".", "getName", "(", ")", ",", "connection", ")", "!=", "null", ")", "{", "throw", "SeedException", ".", "createNew", "(", "JmsErrorCode", ".", "DUPLICATE_CONNECTION_NAME", ")", ".", "put", "(", "ERROR_CONNECTION_NAME", ",", "connectionDefinition", ".", "getName", "(", ")", ")", ";", "}", "if", "(", "shouldStartConnections", ".", "get", "(", ")", ")", "{", "try", "{", "connection", ".", "start", "(", ")", ";", "}", "catch", "(", "JMSException", "e", ")", "{", "throw", "SeedException", ".", "wrap", "(", "e", ",", "JmsErrorCode", ".", "UNABLE_TO_START_JMS_CONNECTION", ")", ".", "put", "(", "ERROR_CONNECTION_NAME", ",", "connectionDefinition", ".", "getName", "(", ")", ")", ";", "}", "}", "}" ]

[ "Register", "an", "existing", "JMS", "connection", "to", "be", "managed", "by", "the", "JMS", "plugin", "." ]

[ "protected", "ArrayDBIDs", "affectedRkNN", "(", "List", "<", "?", "extends", "Collection", "<", "DoubleDBIDPair", ">", ">", "extract", ",", "DBIDs", "remove", ")", "{", "HashSetModifiableDBIDs", "ids", "=", "DBIDUtil", ".", "newHashSet", "(", ")", ";", "for", "(", "Collection", "<", "DoubleDBIDPair", ">", "drps", ":", "extract", ")", "{", "for", "(", "DoubleDBIDPair", "drp", ":", "drps", ")", "{", "ids", ".", "add", "(", "drp", ")", ";", "}", "}", "ids", ".", "removeDBIDs", "(", "remove", ")", ";", "// Convert back to array", "return", "DBIDUtil", ".", "newArray", "(", "ids", ")", ";", "}" ]

[ "Extracts", "and", "removes", "the", "DBIDs", "in", "the", "given", "collections", "." ]

[ "public", "ThreadContextClassLoaderHolder", "buildAndSet", "(", ")", "{", "// Create the URLClassLoader from the supplied URLs", "final", "URL", "[", "]", "allURLs", "=", "new", "URL", "[", "urlList", ".", "size", "(", ")", "]", ";", "urlList", ".", "toArray", "(", "allURLs", ")", ";", "final", "URLClassLoader", "classLoader", "=", "new", "URLClassLoader", "(", "allURLs", ",", "originalClassLoader", ")", ";", "// Assign the ThreadContext ClassLoader", "final", "Thread", "currentThread", "=", "Thread", ".", "currentThread", "(", ")", ";", "currentThread", ".", "setContextClassLoader", "(", "classLoader", ")", ";", "// Build the classpath argument", "StringBuilder", "builder", "=", "new", "StringBuilder", "(", ")", ";", "try", "{", "for", "(", "URL", "current", ":", "Collections", ".", "list", "(", "classLoader", ".", "getResources", "(", "\"\"", ")", ")", ")", "{", "final", "String", "toAppend", "=", "getClassPathElement", "(", "current", ",", "encoding", ")", ";", "if", "(", "toAppend", "!=", "null", ")", "{", "builder", ".", "append", "(", "toAppend", ")", ".", "append", "(", "File", ".", "pathSeparator", ")", ";", "}", "}", "}", "catch", "(", "Exception", "e", ")", "{", "// Restore the original classloader to the active thread before failing.", "currentThread", ".", "setContextClassLoader", "(", "originalClassLoader", ")", ";", "throw", "new", "IllegalStateException", "(", "\"Could not synthesize classpath from original classloader.\"", ",", "e", ")", ";", "}", "final", "String", "classPathString", "=", "builder", ".", "length", "(", ")", ">", "0", "?", "builder", ".", "toString", "(", ")", ".", "substring", "(", "0", ",", "builder", ".", "length", "(", ")", "-", "File", ".", "pathSeparator", ".", "length", "(", ")", ")", ":", "\"\"", ";", "// All done.", "return", "new", "DefaultHolder", "(", "currentThread", ",", "this", ".", "originalClassLoader", ",", "classPathString", ")", ";", "}" ]

[ "<p", ">", "This", "method", "performs", "2", "things", "in", "order", ":", "<", "/", "p", ">", "<ol", ">", "<li", ">", "Builds", "a", "ThreadContext", "ClassLoader", "from", "the", "URLs", "supplied", "to", "this", "Builder", "and", "assigns", "the", "newly", "built", "ClassLoader", "to", "the", "current", "Thread", ".", "<", "/", "li", ">", "<li", ">", "Stores", "the", "ThreadContextClassLoaderHolder", "for", "later", "restoration", ".", "<", "/", "li", ">", "<", "/", "ol", ">", "References", "to", "the", "original", "ThreadContextClassLoader", "and", "the", "currentThread", "are", "stored", "within", "the", "returned", "ThreadContextClassLoaderHolder", "and", "can", "be", "restored", "by", "a", "call", "to", "{", "@code", "ThreadContextClassLoaderHolder", ".", "restoreClassLoaderAndReleaseThread", "()", "}", "." ]

[ "public", "static", "int", "findIterations", "(", "Argon2", "argon2", ",", "long", "maxMillisecs", ",", "int", "memory", ",", "int", "parallelism", ",", "IterationLogger", "logger", ")", "{", "char", "[", "]", "password", "=", "\"password\"", ".", "toCharArray", "(", ")", ";", "warmup", "(", "argon2", ",", "password", ")", ";", "long", "took", ";", "int", "iterations", "=", "0", ";", "do", "{", "iterations", "++", ";", "long", "start", "=", "System", ".", "nanoTime", "(", ")", "/", "MILLIS_IN_NANOS", ";", "argon2", ".", "hash", "(", "iterations", ",", "memory", ",", "parallelism", ",", "password", ")", ";", "long", "end", "=", "System", ".", "nanoTime", "(", ")", "/", "MILLIS_IN_NANOS", ";", "took", "=", "end", "-", "start", ";", "logger", ".", "log", "(", "iterations", ",", "took", ")", ";", "}", "while", "(", "took", "<=", "maxMillisecs", ")", ";", "return", "iterations", "-", "1", ";", "}" ]

[ "Finds", "the", "number", "of", "iterations", "so", "that", "the", "hash", "function", "takes", "at", "most", "the", "given", "number", "of", "milliseconds", "." ]

[ "public", "EnvelopeDocument", "updateDocument", "(", "String", "accountId", ",", "String", "templateId", ",", "String", "documentId", ",", "EnvelopeDefinition", "envelopeDefinition", ")", "throws", "ApiException", "{", "return", "updateDocument", "(", "accountId", ",", "templateId", ",", "documentId", ",", "envelopeDefinition", ",", "null", ")", ";", "}" ]

[ "Adds", "a", "document", "to", "a", "template", "document", ".", "Adds", "the", "specified", "document", "to", "an", "existing", "template", "document", "." ]

[ "public", "void", "setRotate", "(", "double", "cosA", ",", "double", "sinA", ")", "{", "xx", "=", "cosA", ";", "xy", "=", "-", "sinA", ";", "xd", "=", "0", ";", "yx", "=", "sinA", ";", "yy", "=", "cosA", ";", "yd", "=", "0", ";", "}" ]

[ "Sets", "rotation", "for", "this", "transformation", "." ]

[ "private", "ClientMessage", "invokeAddInternal", "(", "long", "delta", ",", "boolean", "getBeforeUpdate", ",", "List", "<", "Address", ">", "excludedAddresses", ",", "HazelcastException", "lastException", ",", "Address", "target", ")", "{", "if", "(", "target", "==", "null", ")", "{", "throw", "lastException", "!=", "null", "?", "lastException", ":", "new", "NoDataMemberInClusterException", "(", "\"Cannot invoke operations on a CRDT because the cluster does not contain any data members\"", ")", ";", "}", "try", "{", "final", "ClientMessage", "request", "=", "PNCounterAddCodec", ".", "encodeRequest", "(", "name", ",", "delta", ",", "getBeforeUpdate", ",", "observedClock", ".", "entrySet", "(", ")", ",", "target", ")", ";", "return", "invokeOnAddress", "(", "request", ",", "target", ")", ";", "}", "catch", "(", "HazelcastException", "e", ")", "{", "logger", ".", "fine", "(", "\"Unable to provide session guarantees when sending operations to \"", "+", "target", "+", "\", choosing different target\"", ")", ";", "if", "(", "excludedAddresses", "==", "EMPTY_ADDRESS_LIST", ")", "{", "excludedAddresses", "=", "new", "ArrayList", "<", "Address", ">", "(", ")", ";", "}", "excludedAddresses", ".", "add", "(", "target", ")", ";", "final", "Address", "newTarget", "=", "getCRDTOperationTarget", "(", "excludedAddresses", ")", ";", "return", "invokeAddInternal", "(", "delta", ",", "getBeforeUpdate", ",", "excludedAddresses", ",", "e", ",", "newTarget", ")", ";", "}", "}" ]

[ "Adds", "the", "{", "@code", "delta", "}", "and", "returns", "the", "value", "of", "the", "counter", "before", "the", "update", "if", "{", "@code", "getBeforeUpdate", "}", "is", "{", "@code", "true", "}", "or", "the", "value", "after", "the", "update", "if", "it", "is", "{", "@code", "false", "}", ".", "It", "will", "invoke", "client", "messages", "recursively", "on", "viable", "replica", "addresses", "until", "successful", "or", "the", "list", "of", "viable", "replicas", "is", "exhausted", ".", "Replicas", "with", "addresses", "contained", "in", "the", "{", "@code", "excludedAddresses", "}", "are", "skipped", ".", "If", "there", "are", "no", "viable", "replicas", "this", "method", "will", "throw", "the", "{", "@code", "lastException", "}", "if", "not", "{", "@code", "null", "}", "or", "a", "{", "@link", "NoDataMemberInClusterException", "}", "if", "the", "{", "@code", "lastException", "}", "is", "{", "@code", "null", "}", "." ]

[ "public", "int", "countDifferencesBetweenIgnoreWhitespaceAnd", "(", "String", "first", ",", "String", "second", ")", "{", "String", "cleanFirst", "=", "allWhitespaceToSingleSpace", "(", "first", ")", ";", "String", "cleanSecond", "=", "allWhitespaceToSingleSpace", "(", "second", ")", ";", "return", "countDifferencesBetweenAnd", "(", "cleanFirst", ",", "cleanSecond", ")", ";", "}" ]

[ "Determines", "number", "of", "differences", "(", "substrings", "that", "are", "not", "equal", ")", "between", "two", "strings", "ignoring", "differences", "in", "whitespace", "." ]

[ "private", "@", "Nullable", "CacheWriterException", "writeAllToCacheWriter", "(", "Map", "<", "?", "extends", "K", ",", "?", "extends", "V", ">", "map", ")", "{", "if", "(", "!", "configuration", ".", "isWriteThrough", "(", ")", "||", "map", ".", "isEmpty", "(", ")", ")", "{", "return", "null", ";", "}", "List", "<", "Cache", ".", "Entry", "<", "?", "extends", "K", ",", "?", "extends", "V", ">", ">", "entries", "=", "map", ".", "entrySet", "(", ")", ".", "stream", "(", ")", ".", "map", "(", "entry", "->", "new", "EntryProxy", "<>", "(", "entry", ".", "getKey", "(", ")", ",", "entry", ".", "getValue", "(", ")", ")", ")", ".", "collect", "(", "toList", "(", ")", ")", ";", "try", "{", "writer", ".", "writeAll", "(", "entries", ")", ";", "return", "null", ";", "}", "catch", "(", "CacheWriterException", "e", ")", "{", "entries", ".", "forEach", "(", "entry", "->", "{", "map", ".", "remove", "(", "entry", ".", "getKey", "(", ")", ")", ";", "}", ")", ";", "throw", "e", ";", "}", "catch", "(", "RuntimeException", "e", ")", "{", "entries", ".", "forEach", "(", "entry", "->", "{", "map", ".", "remove", "(", "entry", ".", "getKey", "(", ")", ")", ";", "}", ")", ";", "return", "new", "CacheWriterException", "(", "\"Exception in CacheWriter\"", ",", "e", ")", ";", "}", "}" ]

[ "Writes", "all", "of", "the", "entries", "to", "the", "cache", "writer", "if", "write", "-", "through", "is", "enabled", "." ]

[ "public", "void", "offerStatement", "(", "int", "stmtHash", ",", "int", "offset", ",", "ByteBuffer", "psetBuffer", ")", "{", "m_inputCRC", ".", "update", "(", "stmtHash", ")", ";", "m_inputCRC", ".", "updateFromPosition", "(", "offset", ",", "psetBuffer", ")", ";", "if", "(", "m_hashCount", "<", "MAX_HASHES_COUNT", ")", "{", "m_hashes", "[", "m_hashCount", "]", "=", "stmtHash", ";", "m_hashes", "[", "m_hashCount", "+", "1", "]", "=", "(", "int", ")", "m_inputCRC", ".", "getValue", "(", ")", ";", "}", "m_hashCount", "+=", "2", ";", "}" ]

[ "Update", "the", "overall", "hash", ".", "Add", "a", "pair", "of", "ints", "to", "the", "array", "if", "the", "size", "isn", "t", "too", "large", "." ]

[ "private", "Criteria", "buildPrefetchCriteriaSingleKey", "(", "Collection", "ids", ",", "FieldDescriptor", "field", ")", "{", "Criteria", "crit", "=", "new", "Criteria", "(", ")", ";", "ArrayList", "values", "=", "new", "ArrayList", "(", "ids", ".", "size", "(", ")", ")", ";", "Iterator", "iter", "=", "ids", ".", "iterator", "(", ")", ";", "Identity", "id", ";", "while", "(", "iter", ".", "hasNext", "(", ")", ")", "{", "id", "=", "(", "Identity", ")", "iter", ".", "next", "(", ")", ";", "values", ".", "add", "(", "id", ".", "getPrimaryKeyValues", "(", ")", "[", "0", "]", ")", ";", "}", "switch", "(", "values", ".", "size", "(", ")", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "crit", ".", "addEqualTo", "(", "field", ".", "getAttributeName", "(", ")", ",", "values", ".", "get", "(", "0", ")", ")", ";", "break", ";", "default", ":", "// create IN (...) for the single key field\r", "crit", ".", "addIn", "(", "field", ".", "getAttributeName", "(", ")", ",", "values", ")", ";", "break", ";", "}", "return", "crit", ";", "}" ]

[ "Build", "the", "Criteria", "using", "IN", "(", "...", ")", "for", "single", "keys" ]

[ "@", "Override", "public", "void", "findNeighbor", "(", "P", "target", ",", "int", "searchN", ",", "FastQueue", "<", "KdTreeResult", ">", "results", ")", "{", "if", "(", "searchN", "<=", "0", ")", "throw", "new", "IllegalArgumentException", "(", "\"I'm sorry, but I refuse to search for less than or equal to 0 neighbors.\"", ")", ";", "if", "(", "tree", ".", "root", "==", "null", ")", "return", ";", "this", ".", "searchN", "=", "searchN", ";", "this", ".", "target", "=", "target", ";", "this", ".", "mostDistantNeighborSq", "=", "maxDistanceSq", ";", "stepClosest", "(", "tree", ".", "root", ",", "results", ")", ";", "}" ]

[ "Finds", "the", "nodes", "which", "are", "closest", "to", "target", "and", "within", "range", "of", "the", "maximum", "distance", "." ]

[ "public", "static", "Betner", "after", "(", "String", "target", ",", "String", "separator", ")", "{", "return", "betn", "(", "target", ")", ".", "after", "(", "separator", ")", ";", "}" ]

[ "Returns", "a", "{", "@code", "String", "}", "between", "matcher", "that", "matches", "any", "character", "in", "the", "given", "left", "and", "ending" ]

[ "public", "LogSeqNum", "logSetVal", "(", "Buffer", "buff", ",", "int", "offset", ",", "Constant", "newVal", ")", "{", "if", "(", "enableLogging", ")", "{", "BlockId", "blk", "=", "buff", ".", "block", "(", ")", ";", "if", "(", "isTempBlock", "(", "blk", ")", ")", "return", "null", ";", "return", "new", "SetValueRecord", "(", "txNum", ",", "blk", ",", "offset", ",", "buff", ".", "getVal", "(", "offset", ",", "newVal", ".", "getType", "(", ")", ")", ",", "newVal", ")", ".", "writeToLog", "(", ")", ";", "}", "else", "return", "null", ";", "}" ]

[ "Writes", "a", "set", "value", "record", "to", "the", "log", "." ]

[ "public", "static", "boolean", "VerifyStrings", "(", "String", "signature", ",", "String", "message", ",", "String", "publicKey", ")", "throws", "LRException", "{", "// Check that none of the inputs are null", "if", "(", "signature", "==", "null", "||", "message", "==", "null", "||", "publicKey", "==", "null", ")", "{", "throw", "new", "LRException", "(", "LRException", ".", "NULL_FIELD", ")", ";", "}", "// Convert all inputs into input streams", "InputStream", "isSignature", "=", "null", ";", "InputStream", "isMessage", "=", "null", ";", "InputStream", "isPublicKey", "=", "null", ";", "try", "{", "isSignature", "=", "new", "ByteArrayInputStream", "(", "signature", ".", "getBytes", "(", ")", ")", ";", "isMessage", "=", "new", "ByteArrayInputStream", "(", "message", ".", "getBytes", "(", ")", ")", ";", "isPublicKey", "=", "new", "ByteArrayInputStream", "(", "publicKey", ".", "getBytes", "(", ")", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "LRException", "(", "LRException", ".", "INPUT_STREAM_FAILED", ")", ";", "}", "// Feed the input streams into the primary verify function", "return", "Verify", "(", "isSignature", ",", "isMessage", ",", "isPublicKey", ")", ";", "}" ]

[ "Converts", "input", "strings", "to", "input", "streams", "for", "the", "main", "verify", "function" ]

[ "public", "static", "void", "validateResults", "(", "Map", "<", "Integer", ",", "Object", ">", "results", ")", "{", "for", "(", "Object", "result", ":", "results", ".", "values", "(", ")", ")", "{", "if", "(", "result", "!=", "null", "&&", "result", "instanceof", "CacheClearResponse", ")", "{", "Object", "response", "=", "(", "(", "CacheClearResponse", ")", "result", ")", ".", "getResponse", "(", ")", ";", "if", "(", "response", "instanceof", "Throwable", ")", "{", "ExceptionUtil", ".", "sneakyThrow", "(", "(", "Throwable", ")", "response", ")", ";", "}", "}", "}", "}" ]

[ "Cache", "clear", "response", "validator", "loop", "on", "results", "to", "validate", "that", "no", "exception", "exists", "on", "the", "result", "map", ".", "Throws", "the", "first", "exception", "in", "the", "map", "." ]

[ "public", "DateTimeFormatterBuilder", "appendText", "(", "DateTimeFieldType", "fieldType", ")", "{", "if", "(", "fieldType", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Field type must not be null\"", ")", ";", "}", "return", "append0", "(", "new", "TextField", "(", "fieldType", ",", "false", ")", ")", ";", "}" ]

[ "Instructs", "the", "printer", "to", "emit", "a", "field", "value", "as", "text", "and", "the", "parser", "to", "expect", "text", "." ]

[ "public", "List", "<", "MetricDefinitionInner", ">", "listMetricDefinitions", "(", "String", "resourceGroupName", ",", "String", "serverName", ",", "String", "databaseName", ")", "{", "return", "listMetricDefinitionsWithServiceResponseAsync", "(", "resourceGroupName", ",", "serverName", ",", "databaseName", ")", ".", "toBlocking", "(", ")", ".", "single", "(", ")", ".", "body", "(", ")", ";", "}" ]

[ "Returns", "database", "metric", "definitions", "." ]

[ "public", "Matrix4f", "scaleLocal", "(", "float", "x", ",", "float", "y", ",", "float", "z", ")", "{", "return", "scaleLocal", "(", "x", ",", "y", ",", "z", ",", "thisOrNew", "(", ")", ")", ";", "}" ]

[ "Pre", "-", "multiply", "scaling", "to", "this", "matrix", "by", "scaling", "the", "base", "axes", "by", "the", "given", "x", "y", "and", "z", "factors", ".", "<p", ">", "If", "<code", ">", "M<", "/", "code", ">", "is", "<code", ">", "this<", "/", "code", ">", "matrix", "and", "<code", ">", "S<", "/", "code", ">", "the", "scaling", "matrix", "then", "the", "new", "matrix", "will", "be", "<code", ">", "S", "*", "M<", "/", "code", ">", ".", "So", "when", "transforming", "a", "vector", "<code", ">", "v<", "/", "code", ">", "with", "the", "new", "matrix", "by", "using", "<code", ">", "S", "*", "M", "*", "v<", "/", "code", ">", "the", "scaling", "will", "be", "applied", "last!" ]

[ "public", "void", "setHeaderValues", "(", "String", "name", ",", "String", "[", "]", "values", ")", "{", "_fields", ".", "put", "(", "name", ",", "Arrays", ".", "asList", "(", "values", ")", ")", ";", "}" ]

[ "Set", "a", "multivalued", "header", "every", "response", "handled", "will", "have", "this", "header", "set", "with", "the", "provided", "values", "." ]

[ "public", "static", "void", "setChar", "(", "MemorySegment", "[", "]", "segments", ",", "int", "offset", ",", "char", "value", ")", "{", "if", "(", "inFirstSegment", "(", "segments", ",", "offset", ",", "2", ")", ")", "{", "segments", "[", "0", "]", ".", "putChar", "(", "offset", ",", "value", ")", ";", "}", "else", "{", "setCharMultiSegments", "(", "segments", ",", "offset", ",", "value", ")", ";", "}", "}" ]

[ "set", "char", "from", "segments", "." ]

[ "public", "static", "void", "copyBitmap", "(", "Bitmap", "dest", ",", "Bitmap", "src", ")", "{", "Preconditions", ".", "checkArgument", "(", "src", ".", "getConfig", "(", ")", "==", "dest", ".", "getConfig", "(", ")", ")", ";", "Preconditions", ".", "checkArgument", "(", "dest", ".", "isMutable", "(", ")", ")", ";", "Preconditions", ".", "checkArgument", "(", "dest", ".", "getWidth", "(", ")", "==", "src", ".", "getWidth", "(", ")", ")", ";", "Preconditions", ".", "checkArgument", "(", "dest", ".", "getHeight", "(", ")", "==", "src", ".", "getHeight", "(", ")", ")", ";", "nativeCopyBitmap", "(", "dest", ",", "dest", ".", "getRowBytes", "(", ")", ",", "src", ",", "src", ".", "getRowBytes", "(", ")", ",", "dest", ".", "getHeight", "(", ")", ")", ";", "}" ]

[ "This", "blits", "the", "pixel", "data", "from", "src", "to", "dest", ".", "<p", ">", "The", "destination", "bitmap", "must", "have", "both", "a", "height", "and", "a", "width", "equal", "to", "the", "source", ".", "For", "maximum", "speed", "stride", "should", "be", "equal", "as", "well", ".", "<p", ">", "Both", "bitmaps", "must", "use", "the", "same", "{" ]

[ "public", "Observable", "<", "ServiceResponse", "<", "List", "<", "Image", ">", ">", ">", "getUntaggedImagesWithServiceResponseAsync", "(", "UUID", "projectId", ",", "GetUntaggedImagesOptionalParameter", "getUntaggedImagesOptionalParameter", ")", "{", "if", "(", "projectId", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Parameter projectId is required and cannot be null.\"", ")", ";", "}", "if", "(", "this", ".", "client", ".", "apiKey", "(", ")", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Parameter this.client.apiKey() is required and cannot be null.\"", ")", ";", "}", "final", "UUID", "iterationId", "=", "getUntaggedImagesOptionalParameter", "!=", "null", "?", "getUntaggedImagesOptionalParameter", ".", "iterationId", "(", ")", ":", "null", ";", "final", "String", "orderBy", "=", "getUntaggedImagesOptionalParameter", "!=", "null", "?", "getUntaggedImagesOptionalParameter", ".", "orderBy", "(", ")", ":", "null", ";", "final", "Integer", "take", "=", "getUntaggedImagesOptionalParameter", "!=", "null", "?", "getUntaggedImagesOptionalParameter", ".", "take", "(", ")", ":", "null", ";", "final", "Integer", "skip", "=", "getUntaggedImagesOptionalParameter", "!=", "null", "?", "getUntaggedImagesOptionalParameter", ".", "skip", "(", ")", ":", "null", ";", "return", "getUntaggedImagesWithServiceResponseAsync", "(", "projectId", ",", "iterationId", ",", "orderBy", ",", "take", ",", "skip", ")", ";", "}" ]

[ "Get", "untagged", "images", "for", "a", "given", "project", "iteration", ".", "This", "API", "supports", "batching", "and", "range", "selection", ".", "By", "default", "it", "will", "only", "return", "first", "50", "images", "matching", "images", ".", "Use", "the", "{", "take", "}", "and", "{", "skip", "}", "parameters", "to", "control", "how", "many", "images", "to", "return", "in", "a", "given", "batch", "." ]

[ "static", "String", "getConfigKey", "(", "InjectionPoint", "ip", ",", "ConfigProperty", "configProperty", ")", "{", "String", "key", "=", "configProperty", ".", "name", "(", ")", ";", "if", "(", "key", ".", "length", "(", ")", ">", "0", ")", "{", "return", "key", ";", "}", "if", "(", "ip", ".", "getAnnotated", "(", ")", "instanceof", "AnnotatedMember", ")", "{", "AnnotatedMember", "member", "=", "(", "AnnotatedMember", ")", "ip", ".", "getAnnotated", "(", ")", ";", "AnnotatedType", "declaringType", "=", "member", ".", "getDeclaringType", "(", ")", ";", "if", "(", "declaringType", "!=", "null", ")", "{", "return", "declaringType", ".", "getJavaClass", "(", ")", ".", "getCanonicalName", "(", ")", "+", "\".\"", "+", "member", ".", "getJavaMember", "(", ")", ".", "getName", "(", ")", ";", "}", "}", "throw", "new", "IllegalStateException", "(", "\"Could not find default name for @ConfigProperty InjectionPoint \"", "+", "ip", ")", ";", "}" ]

[ "Get", "the", "property", "key", "to", "use", ".", "In", "case", "the", "{" ]

[ "public", "com", ".", "squareup", ".", "okhttp", ".", "Call", "getDeviceStatusAsync", "(", "String", "deviceId", ",", "Boolean", "includeSnapshot", ",", "Boolean", "includeSnapshotTimestamp", ",", "final", "ApiCallback", "<", "DeviceStatus", ">", "callback", ")", "throws", "ApiException", "{", "ProgressResponseBody", ".", "ProgressListener", "progressListener", "=", "null", ";", "ProgressRequestBody", ".", "ProgressRequestListener", "progressRequestListener", "=", "null", ";", "if", "(", "callback", "!=", "null", ")", "{", "progressListener", "=", "new", "ProgressResponseBody", ".", "ProgressListener", "(", ")", "{", "@", "Override", "public", "void", "update", "(", "long", "bytesRead", ",", "long", "contentLength", ",", "boolean", "done", ")", "{", "callback", ".", "onDownloadProgress", "(", "bytesRead", ",", "contentLength", ",", "done", ")", ";", "}", "}", ";", "progressRequestListener", "=", "new", "ProgressRequestBody", ".", "ProgressRequestListener", "(", ")", "{", "@", "Override", "public", "void", "onRequestProgress", "(", "long", "bytesWritten", ",", "long", "contentLength", ",", "boolean", "done", ")", "{", "callback", ".", "onUploadProgress", "(", "bytesWritten", ",", "contentLength", ",", "done", ")", ";", "}", "}", ";", "}", "com", ".", "squareup", ".", "okhttp", ".", "Call", "call", "=", "getDeviceStatusValidateBeforeCall", "(", "deviceId", ",", "includeSnapshot", ",", "includeSnapshotTimestamp", ",", "progressListener", ",", "progressRequestListener", ")", ";", "Type", "localVarReturnType", "=", "new", "TypeToken", "<", "DeviceStatus", ">", "(", ")", "{", "}", ".", "getType", "(", ")", ";", "apiClient", ".", "executeAsync", "(", "call", ",", "localVarReturnType", ",", "callback", ")", ";", "return", "call", ";", "}" ]

[ "Get", "Device", "Status", "(", "asynchronously", ")", "Get", "Device", "Status" ]

[ "public", "static", "<", "S", "extends", "Sequence", "<", "S", ">", ">", "Alignment", "<", "S", ">", "rightTrimAlignment", "(", "Alignment", "<", "S", ">", "alignment", ",", "AlignmentScoring", "<", "S", ">", "scoring", ")", "{", "if", "(", "scoring", "instanceof", "LinearGapAlignmentScoring", ")", "return", "rightTrimAlignment", "(", "alignment", ",", "(", "LinearGapAlignmentScoring", "<", "S", ">", ")", "scoring", ")", ";", "else", "if", "(", "scoring", "instanceof", "AffineGapAlignmentScoring", ")", "return", "rightTrimAlignment", "(", "alignment", ",", "(", "AffineGapAlignmentScoring", "<", "S", ">", ")", "scoring", ")", ";", "else", "throw", "new", "IllegalArgumentException", "(", "\"Unknown scoring type\"", ")", ";", "}" ]

[ "Try", "increase", "total", "alignment", "score", "by", "partially", "(", "or", "fully", ")", "trimming", "it", "from", "right", "side", ".", "If", "score", "can", "t", "be", "increased", "the", "same", "alignment", "will", "be", "returned", "." ]

[ "public", "Closeable", "onMyWalletEvent", "(", "final", "BiConsumer", "<", "BitfinexAccountSymbol", ",", "Collection", "<", "BitfinexWallet", ">", ">", "listener", ")", "{", "walletConsumers", ".", "offer", "(", "listener", ")", ";", "return", "(", ")", "->", "walletConsumers", ".", "remove", "(", "listener", ")", ";", "}" ]

[ "registers", "listener", "for", "user", "account", "related", "events", "-", "wallet", "change", "events" ]

[ "public", "static", "TypedValue", "untypedValue", "(", "Object", "value", ")", "{", "if", "(", "value", "instanceof", "TypedValue", ")", "{", "return", "untypedValue", "(", "value", ",", "(", "(", "TypedValue", ")", "value", ")", ".", "isTransient", "(", ")", ")", ";", "}", "else", "return", "untypedValue", "(", "value", ",", "false", ")", ";", "}" ]

[ "Creates", "an", "untyped", "value", "i", ".", "e", ".", "{" ]

[ "public", "PactDslJsonArray", "eachLike", "(", "PactDslJsonRootValue", "value", ",", "int", "numberExamples", ")", "{", "if", "(", "numberExamples", "==", "0", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Testing Zero examples is unsafe. Please make sure to provide at least one \"", "+", "\"example in the Pact provider implementation. See https://github.com/DiUS/pact-jvm/issues/546\"", ")", ";", "}", "matchers", ".", "addRule", "(", "rootPath", "+", "appendArrayIndex", "(", "1", ")", ",", "matchMin", "(", "0", ")", ")", ";", "PactDslJsonArray", "parent", "=", "new", "PactDslJsonArray", "(", "rootPath", ",", "\"\"", ",", "this", ",", "true", ")", ";", "parent", ".", "setNumberExamples", "(", "numberExamples", ")", ";", "parent", ".", "putObject", "(", "value", ")", ";", "return", "(", "PactDslJsonArray", ")", "parent", ".", "closeArray", "(", ")", ";", "}" ]

[ "Array", "of", "values", "that", "are", "not", "objects", "where", "each", "item", "must", "match", "the", "provided", "example" ]

[ "public", "List", "<", "ExecutableFlow", ">", "fetchFlowHistory", "(", "final", "int", "projectId", ",", "final", "String", "flowId", ",", "final", "long", "startTime", ")", "throws", "ExecutorManagerException", "{", "try", "{", "return", "this", ".", "dbOperator", ".", "query", "(", "FetchExecutableFlows", ".", "FETCH_EXECUTABLE_FLOW_BY_START_TIME", ",", "new", "FetchExecutableFlows", "(", ")", ",", "projectId", ",", "flowId", ",", "startTime", ")", ";", "}", "catch", "(", "final", "SQLException", "e", ")", "{", "throw", "new", "ExecutorManagerException", "(", "\"Error fetching historic flows\"", ",", "e", ")", ";", "}", "}" ]

[ "fetch", "flow", "execution", "history", "with", "specified", "{", "@code", "projectId", "}", "{", "@code", "flowId", "}", "and", "flow", "start", "time", ">", "=", "{", "@code", "startTime", "}" ]

[ "@", "Deprecated", "public", "static", "Process", "getProcess", "(", "String", "mainClass", ",", "String", "...", "args", ")", "throws", "LauncherException", ",", "IOException", "{", "return", "getProcessBuilder", "(", "mainClass", ",", "args", ")", ".", "start", "(", ")", ";", "}" ]

[ "Get", "a", "process", "for", "a", "JVM", ".", "The", "class", "path", "for", "the", "JVM", "is", "computed", "based", "on", "the", "class", "loaders", "for", "the", "main", "class", "." ]

[ "public", "OvhPrice", "xdsl_options_ipv4_ipRange_GET", "(", "net", ".", "minidev", ".", "ovh", ".", "api", ".", "price", ".", "xdsl", ".", "options", ".", "OvhIpv4Enum", "ipRange", ")", "throws", "IOException", "{", "String", "qPath", "=", "\"/price/xdsl/options/ipv4/{ipRange}\"", ";", "StringBuilder", "sb", "=", "path", "(", "qPath", ",", "ipRange", ")", ";", "String", "resp", "=", "exec", "(", "qPath", ",", "\"GET\"", ",", "sb", ".", "toString", "(", ")", ",", "null", ")", ";", "return", "convertTo", "(", "resp", ",", "OvhPrice", ".", "class", ")", ";", "}" ]

[ "Get", "the", "price", "of", "IPv4", "options" ]

[ "public", "static", "final", "Function", "<", "String", "[", "]", ",", "Interval", ">", "strFieldArrayToInterval", "(", "String", "pattern", ",", "DateTimeZone", "dateTimeZone", ")", "{", "return", "new", "StringFieldArrayToInterval", "(", "pattern", ",", "dateTimeZone", ")", ";", "}" ]

[ "<p", ">", "It", "converts", "the", "input", "{", "@link", "String", "}", "elements", "into", "an", "{", "@link", "Interval", "}", ".", "The", "target", "{", "@link", "String", "}", "elements", "represent", "the", "start", "and", "end", "of", "the", "{", "@link", "Interval", "}", ".", "<", "/", "p", ">" ]

[ "public", "static", "boolean", "isToday", "(", "String", "date", ",", "String", "format", ")", "{", "String", "now", "=", "getFormatDate", "(", "SHORT", ")", ";", "String", "target", "=", "getFormatDate", "(", "SHORT", ",", "parse", "(", "date", ",", "format", ")", ")", ";", "return", "now", ".", "equals", "(", "target", ")", ";", "}" ]

[ "查询时间是否在今日" ]

[ "private", "ModelMetrics", "makeModelMetrics", "(", "SharedTreeModel", "model", ",", "Frame", "fr", ",", "Frame", "adaptedFr", ",", "Frame", "preds", ")", "{", "ModelMetrics", "mm", ";", "if", "(", "model", ".", "_output", ".", "nclasses", "(", ")", "==", "2", "&&", "_computeGainsLift", ")", "{", "assert", "preds", "!=", "null", ":", "\"Predictions were pre-created\"", ";", "mm", "=", "_mb", ".", "makeModelMetrics", "(", "model", ",", "fr", ",", "adaptedFr", ",", "preds", ")", ";", "}", "else", "{", "boolean", "calculatePreds", "=", "preds", "==", "null", "&&", "model", ".", "_parms", ".", "_distribution", "==", "DistributionFamily", ".", "huber", ";", "// FIXME: PUBDEV-4992 we should avoid doing full scoring!", "if", "(", "calculatePreds", ")", "{", "Log", ".", "warn", "(", "\"Going to calculate predictions from scratch. This can be expensive for large models! See PUBDEV-4992\"", ")", ";", "preds", "=", "model", ".", "score", "(", "fr", ")", ";", "}", "mm", "=", "_mb", ".", "makeModelMetrics", "(", "model", ",", "fr", ",", "null", ",", "preds", ")", ";", "if", "(", "calculatePreds", "&&", "(", "preds", "!=", "null", ")", ")", "preds", ".", "remove", "(", ")", ";", "}", "return", "mm", ";", "}" ]

[ "Run", "after", "the", "doAll", "scoring", "to", "convert", "the", "MetricsBuilder", "to", "a", "ModelMetrics" ]

[ "public", "OvhIpxe", "ipxeScript_POST", "(", "String", "description", ",", "String", "name", ",", "String", "script", ")", "throws", "IOException", "{", "String", "qPath", "=", "\"/me/ipxeScript\"", ";", "StringBuilder", "sb", "=", "path", "(", "qPath", ")", ";", "HashMap", "<", "String", ",", "Object", ">", "o", "=", "new", "HashMap", "<", "String", ",", "Object", ">", "(", ")", ";", "addBody", "(", "o", ",", "\"description\"", ",", "description", ")", ";", "addBody", "(", "o", ",", "\"name\"", ",", "name", ")", ";", "addBody", "(", "o", ",", "\"script\"", ",", "script", ")", ";", "String", "resp", "=", "exec", "(", "qPath", ",", "\"POST\"", ",", "sb", ".", "toString", "(", ")", ",", "o", ")", ";", "return", "convertTo", "(", "resp", ",", "OvhIpxe", ".", "class", ")", ";", "}" ]

[ "Add", "an", "IPXE", "script" ]

[ "public", "static", "Timer", "setTimeout", "(", "int", "milliseconds", ",", "TimerCallback", "callback", ")", "{", "TimeoutTimer", "timeout", "=", "new", "TimeoutTimer", "(", ")", ";", "timeout", ".", "setId", "(", "nativeSetTimeout", "(", "milliseconds", ",", "callback", ",", "timeout", ")", ")", ";", "return", "timeout", ";", "}" ]

[ "Defines", "a", "one", "-", "shot", "timer", "." ]

[ "public", "final", "boolean", "defineSynthesizedProperty", "(", "String", "propertyName", ",", "JSType", "type", ",", "Node", "propertyNode", ")", "{", "return", "defineProperty", "(", "propertyName", ",", "type", ",", "false", ",", "propertyNode", ")", ";", "}" ]

[ "Defines", "a", "property", "whose", "type", "is", "on", "a", "synthesized", "object", ".", "These", "objects", "don", "t", "actually", "exist", "in", "the", "user", "s", "program", ".", "They", "re", "just", "used", "for", "bookkeeping", "in", "the", "type", "system", "." ]

[ "public", "static", "int", "fromHSL", "(", "float", "h", ",", "float", "s", ",", "float", "l", ")", "{", "int", "alpha", "=", "MAX_INT", ";", "return", "fromHSL", "(", "h", ",", "s", ",", "l", ",", "alpha", ")", ";", "}" ]

[ "Method", "to", "transform", "from", "HSL", "to", "RGB", "(", "this", "method", "sets", "alpha", "as", "0xff", ")" ]

[ "public", "Set", "<", "BioPAXElement", ">", "fetch", "(", "final", "BioPAXElement", "bpe", ",", "int", "depth", ")", "{", "//a sanity check", "if", "(", "depth", "<=", "0", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"fetch(..), not a positive 'depth':\"", "+", "depth", ")", ";", "}", "final", "Set", "<", "BioPAXElement", ">", "children", "=", "new", "HashSet", "<", "BioPAXElement", ">", "(", ")", ";", "//create a simple traverser to collect direct child elements", "Traverser", "traverser", "=", "new", "Traverser", "(", "editorMap", ",", "new", "Visitor", "(", ")", "{", "@", "Override", "public", "void", "visit", "(", "BioPAXElement", "domain", ",", "Object", "range", ",", "Model", "model", ",", "PropertyEditor", "<", "?", ",", "?", ">", "editor", ")", "{", "children", ".", "add", "(", "(", "BioPAXElement", ")", "range", ")", ";", "}", "}", ",", "filters", ")", ";", "//run", "traverser", ".", "traverse", "(", "bpe", ",", "null", ")", ";", "if", "(", "!", "children", ".", "isEmpty", "(", ")", "&&", "--", "depth", ">", "0", ")", "{", "for", "(", "BioPAXElement", "element", ":", "new", "HashSet", "<", "BioPAXElement", ">", "(", "children", ")", ")", "{", "if", "(", "skipSubPathways", "&&", "(", "element", "instanceof", "Pathway", ")", ")", "continue", ";", "Set", "<", "BioPAXElement", ">", "nextLevelElements", "=", "fetch", "(", "element", ",", "depth", ")", ";", "//recursion goes on", "children", ".", "addAll", "(", "nextLevelElements", ")", ";", "}", "}", "//remove itself (if added due to tricky loops in the model...)", "children", ".", "remove", "(", "bpe", ")", ";", "return", "children", ";", "}" ]

[ "Recursively", "collects", "unique", "child", "objects", "from", "BioPAX", "object", "type", "properties", "that", "pass", "all", "the", "filters", "(", "as", "set", "via", "Constructor", ")", "." ]

[ "private", "void", "appendLikeCriteria", "(", "TableAlias", "alias", ",", "PathInfo", "pathInfo", ",", "LikeCriteria", "c", ",", "StringBuffer", "buf", ")", "{", "appendColName", "(", "alias", ",", "pathInfo", ",", "c", ".", "isTranslateAttribute", "(", ")", ",", "buf", ")", ";", "buf", ".", "append", "(", "c", ".", "getClause", "(", ")", ")", ";", "appendParameter", "(", "c", ".", "getValue", "(", ")", ",", "buf", ")", ";", "buf", ".", "append", "(", "m_platform", ".", "getEscapeClause", "(", "c", ")", ")", ";", "}" ]

[ "Answer", "the", "SQL", "-", "Clause", "for", "a", "LikeCriteria" ]

[ "private", "void", "createClassLevelAccumulators", "(", "OnDemandStatsProducer", "<", "T", ">", "producer", ",", "Class", "producerClass", ")", "{", "//several @Accumulators in accumulators holder", "Accumulates", "accAnnotationHolder", "=", "AnnotationUtils", ".", "findAnnotation", "(", "producerClass", ",", "Accumulates", ".", "class", ")", ";", "//(Accumulates) producerClass.getAnnotation(Accumulates.class);", "if", "(", "accAnnotationHolder", "!=", "null", ")", "{", "Accumulate", "[", "]", "accAnnotations", "=", "accAnnotationHolder", ".", "value", "(", ")", ";", "for", "(", "Accumulate", "accAnnotation", ":", "accAnnotations", ")", "{", "createAccumulator", "(", "producer", ".", "getProducerId", "(", ")", ",", "accAnnotation", ",", "formAccumulatorNameForClass", "(", "producer", ",", "accAnnotation", ")", ",", "\"cumulated\"", ")", ";", "}", "}", "//If there is no @Accumulates annotation but @Accumulate is present", "Accumulate", "annotation", "=", "AnnotationUtils", ".", "findAnnotation", "(", "producerClass", ",", "Accumulate", ".", "class", ")", ";", "//producerClass.getAnnotation(Accumulate.class);", "createAccumulator", "(", "producer", ".", "getProducerId", "(", ")", ",", "annotation", ",", "formAccumulatorNameForClass", "(", "producer", ",", "annotation", ")", ",", "\"cumulated\"", ")", ";", "}" ]

[ "Create", "accumulators", "for", "class", "." ]

[ "protected", "int", "addConics", "(", "List", "<", "AssociatedPairConic", ">", "points", ",", "DMatrixRMaj", "A", ",", "int", "rows", ")", "{", "if", "(", "exhaustiveConics", ")", "{", "// adds an exhaustive set of linear conics", "for", "(", "int", "i", "=", "0", ";", "i", "<", "points", ".", "size", "(", ")", ";", "i", "++", ")", "{", "for", "(", "int", "j", "=", "i", "+", "1", ";", "j", "<", "points", ".", "size", "(", ")", ";", "j", "++", ")", "{", "rows", "=", "addConicPairConstraints", "(", "points", ".", "get", "(", "i", ")", ",", "points", ".", "get", "(", "j", ")", ",", "A", ",", "rows", ")", ";", "}", "}", "}", "else", "{", "// adds pairs and has linear time complexity", "for", "(", "int", "i", "=", "1", ";", "i", "<", "points", ".", "size", "(", ")", ";", "i", "++", ")", "{", "rows", "=", "addConicPairConstraints", "(", "points", ".", "get", "(", "i", "-", "1", ")", ",", "points", ".", "get", "(", "i", ")", ",", "A", ",", "rows", ")", ";", "}", "int", "N", "=", "points", ".", "size", "(", ")", ";", "rows", "=", "addConicPairConstraints", "(", "points", ".", "get", "(", "0", ")", ",", "points", ".", "get", "(", "N", "-", "1", ")", ",", "A", ",", "rows", ")", ";", "}", "return", "rows", ";", "}" ]

[ "<p", ">", "Adds", "the", "9x9", "matrix", "constraint", "for", "each", "pair", "of", "conics", ".", "To", "avoid", "O", "(", "N^2", ")", "growth", "the", "default", "option", "only", "adds", "O", "(", "N", ")", "pairs", ".", "if", "only", "conics", "are", "used", "then", "a", "minimum", "of", "3", "is", "required", ".", "See", "[", "2", "]", ".", "<", "/", "p", ">" ]

[ "public", "static", "double", "logpdf", "(", "double", "val", ",", "double", "rate", ")", "{", "return", "FastMath", ".", "log", "(", ".5", "*", "rate", ")", "-", "rate", "*", "Math", ".", "abs", "(", "val", ")", ";", "}" ]

[ "PDF", "static", "version" ]

[ "@", "Override", "public", "int", "indexOf", "(", "Pair", "<", "T", ",", "I", ">", "element", ")", "{", "return", "matrix", ".", "indexOf", "(", "transactionToIndex", "(", "element", ".", "transaction", ")", ",", "itemToIndex", "(", "element", ".", "item", ")", ")", ";", "}" ]

[ "Provides", "position", "of", "element", "within", "the", "set", ".", "<p", ">", "It", "returns", "-", "1", "if", "the", "element", "does", "not", "exist", "within", "the", "set", "." ]

[ "private", "static", "String", "slurpUtf8Part", "(", "HttpServletRequest", "request", ",", "HttpServletResponse", "response", ",", "String", "name", ",", "int", "maxLength", ")", "throws", "IOException", ",", "ServletException", "{", "Part", "part", "=", "request", ".", "getPart", "(", "name", ")", ";", "if", "(", "part", "==", "null", ")", "{", "response", ".", "sendError", "(", "400", ",", "\"Form field \"", "+", "jq", "(", "name", ")", "+", "\" is missing\"", ")", ";", "return", "null", ";", "}", "byte", "[", "]", "bytes", "=", "new", "byte", "[", "maxLength", "]", ";", "InputStream", "in", "=", "part", ".", "getInputStream", "(", ")", ";", "int", "bytesRead", "=", "in", ".", "read", "(", "bytes", ")", ";", "if", "(", "bytesRead", "==", "-", "1", ")", "{", "return", "\"\"", ";", "}", "String", "s", "=", "StringUtil", ".", "utf8ToString", "(", "bytes", ",", "0", ",", "bytesRead", ")", ";", "if", "(", "in", ".", "read", "(", ")", "!=", "-", "1", ")", "{", "response", ".", "sendError", "(", "400", ",", "\"Field \"", "+", "jq", "(", "name", ")", "+", "\" is too long (the limit is \"", "+", "maxLength", "+", "\" bytes): \"", "+", "jq", "(", "s", ")", ")", ";", "return", "null", ";", "}", "// TODO: We're just assuming the content is UTF-8 text. We should actually check it.", "return", "s", ";", "}" ]

[ "Reads", "in", "a", "single", "field", "of", "a", "multipart", "/", "form", "-", "data", "request", ".", "If", "the", "field", "is", "not", "present", "or", "the", "field", "is", "longer", "than", "maxLength", "we", "ll", "use", "the", "given", "HttpServletResponse", "to", "respond", "with", "an", "error", "and", "then", "return", "null", "." ]

[ "public", "void", "setValue", "(", "ReloadableType", "rtype", ",", "Object", "instance", ",", "Object", "value", ",", "String", "name", ")", "throws", "IllegalAccessException", "{", "//\t\tSystem.err.println(\">setValue(rtype=\" + rtype + \",instance=\" + instance + \",value=\" + value + \",name=\" + name + \")\");", "// Look up through our reloadable hierarchy to find it", "FieldMember", "fieldmember", "=", "rtype", ".", "findInstanceField", "(", "name", ")", ";", "if", "(", "fieldmember", "==", "null", ")", "{", "// If the field is null, there are two possible reasons:", "// 1. The field does not exist in the hierarchy at all", "// 2. The field is on a type just above our topmost reloadable type", "FieldReaderWriter", "frw", "=", "rtype", ".", "locateField", "(", "name", ")", ";", "if", "(", "frw", "==", "null", ")", "{", "// bad code redeployed?", "log", ".", "info", "(", "\"Unexpectedly unable to locate instance field \"", "+", "name", "+", "\" starting from type \"", "+", "rtype", ".", "dottedtypename", "+", "\": clinit running late?\"", ")", ";", "return", ";", "}", "frw", ".", "setValue", "(", "instance", ",", "value", ",", "this", ")", ";", "}", "else", "{", "if", "(", "fieldmember", ".", "isStatic", "(", ")", ")", "{", "throw", "new", "IncompatibleClassChangeError", "(", "\"Expected non-static field \"", "+", "rtype", ".", "dottedtypename", "+", "\".\"", "+", "fieldmember", ".", "getName", "(", ")", ")", ";", "}", "Map", "<", "String", ",", "Object", ">", "typeValues", "=", "values", ".", "get", "(", "fieldmember", ".", "getDeclaringTypeName", "(", ")", ")", ";", "if", "(", "typeValues", "==", "null", ")", "{", "typeValues", "=", "new", "HashMap", "<", "String", ",", "Object", ">", "(", ")", ";", "values", ".", "put", "(", "fieldmember", ".", "getDeclaringTypeName", "(", ")", ",", "typeValues", ")", ";", "}", "typeValues", ".", "put", "(", "name", ",", "value", ")", ";", "}", "}" ]

[ "Set", "the", "value", "of", "a", "field", "." ]

[ "protected", "VectorApproximation", "calculateFullApproximation", "(", "DBID", "id", ",", "V", "dv", ")", "{", "int", "[", "]", "approximation", "=", "new", "int", "[", "dv", ".", "getDimensionality", "(", ")", "]", ";", "for", "(", "int", "d", "=", "0", ";", "d", "<", "splitPartitions", ".", "length", ";", "d", "++", ")", "{", "double", "[", "]", "split", "=", "daFiles", ".", "get", "(", "d", ")", ".", "getSplitPositions", "(", ")", ";", "final", "double", "val", "=", "dv", ".", "doubleValue", "(", "d", ")", ";", "final", "int", "lastBorderIndex", "=", "split", ".", "length", "-", "1", ";", "// Value is below data grid", "if", "(", "val", "<", "split", "[", "0", "]", ")", "{", "approximation", "[", "d", "]", "=", "0", ";", "if", "(", "id", "!=", "null", ")", "{", "LOG", ".", "warning", "(", "\"Vector outside of VAFile grid!\"", ")", ";", "}", "}", "// Value is above data grid", "else", "if", "(", "val", ">", "split", "[", "lastBorderIndex", "]", ")", "{", "approximation", "[", "d", "]", "=", "lastBorderIndex", "-", "1", ";", "if", "(", "id", "!=", "null", ")", "{", "LOG", ".", "warning", "(", "\"Vector outside of VAFile grid!\"", ")", ";", "}", "}", "// normal case", "else", "{", "// Search grid position", "int", "pos", "=", "Arrays", ".", "binarySearch", "(", "split", ",", "val", ")", ";", "pos", "=", "(", "pos", ">=", "0", ")", "?", "pos", ":", "(", "(", "-", "pos", ")", "-", "2", ")", ";", "approximation", "[", "d", "]", "=", "pos", ";", "}", "}", "return", "new", "VectorApproximation", "(", "id", ",", "approximation", ")", ";", "}" ]

[ "Calculate", "the", "VA", "file", "position", "given", "the", "existing", "borders", "." ]

[ "public", "static", "String", "forgeName", "(", "Class", "cl", ",", "Method", "m", ",", "ProbeTest", "methodAnnotation", ")", "{", "return", "forgeName", "(", "cl", ",", "m", ".", "getName", "(", ")", ",", "methodAnnotation", ")", ";", "}" ]

[ "Forge", "a", "name", "from", "a", "class", "and", "a", "method", ".", "If", "an", "annotation", "is", "provided", "then", "the", "method", "content", "is", "used", "." ]

[ "public", "TransformersSubRegistration", "getHostRegistration", "(", "final", "ModelVersionRange", "range", ")", "{", "final", "PathAddress", "address", "=", "PathAddress", ".", "EMPTY_ADDRESS", ".", "append", "(", "HOST", ")", ";", "return", "new", "TransformersSubRegistrationImpl", "(", "range", ",", "domain", ",", "address", ")", ";", "}" ]

[ "Get", "the", "sub", "registry", "for", "the", "hosts", "." ]

[ "public", "void", "getEventDetailedInfo", "(", "String", "id", ",", "Callback", "<", "EventDetail", ">", "callback", ")", "throws", "GuildWars2Exception", ",", "NullPointerException", "{", "isParamValid", "(", "new", "ParamChecker", "(", "ParamType", ".", "ID", ",", "id", ")", ")", ";", "gw2API", ".", "getEventDetailedInfo", "(", "id", ",", "GuildWars2", ".", "lang", ".", "getValue", "(", ")", ")", ".", "enqueue", "(", "callback", ")", ";", "}" ]

[ "For", "more", "info", "on", "event", "detail", "API", "go", "<a", "href", "=", "https", ":", "//", "wiki", ".", "guildwars2", ".", "com", "/", "wiki", "/", "API", ":", "1", "/", "event_details", ">", "here<", "/", "a", ">", "<br", "/", ">" ]

[ "public", "StructuredQueryDefinition", "temporalPeriodRange", "(", "Axis", "[", "]", "axes", ",", "TemporalOperator", "operator", ",", "Period", "[", "]", "periods", ",", "String", "...", "options", ")", "{", "if", "(", "axes", "==", "null", ")", "throw", "new", "IllegalArgumentException", "(", "\"axes cannot be null\"", ")", ";", "if", "(", "operator", "==", "null", ")", "throw", "new", "IllegalArgumentException", "(", "\"operator cannot be null\"", ")", ";", "if", "(", "periods", "==", "null", ")", "throw", "new", "IllegalArgumentException", "(", "\"periods cannot be null\"", ")", ";", "return", "new", "TemporalPeriodRangeQuery", "(", "axes", ",", "operator", ",", "periods", ",", "options", ")", ";", "}" ]

[ "Matches", "documents", "that", "have", "a", "value", "in", "the", "specified", "axis", "that", "matches", "the", "specified", "periods", "using", "the", "specified", "operator", "." ]

[ "protected", "void", "callFetchService", "(", "PagedRequest", "request", ",", "AsyncCallback", "<", "R", ">", "callback", ")", "{", "callFetchService", "(", "request", ".", "offset", ",", "request", ".", "count", ",", "request", ".", "needCount", ",", "callback", ")", ";", "}" ]

[ "Calls", "the", "service", "to", "obtain", "data", ".", "Implementations", "should", "make", "a", "service", "call", "using", "the", "callback", "provided", ".", "If", "needCount", "is", "set", "the", "implementation", "should", "also", "request", "the", "total", "number", "of", "items", "from", "the", "server", "(", "this", "is", "normally", "done", "in", "the", "same", "call", "that", "requests", "a", "page", "but", "may", "be", "optional", "for", "performance", "reasons", ")", ".", "By", "default", "this", "calls", "{" ]

[ "public", "void", "addSummaryComment", "(", "Element", "element", ",", "Content", "htmltree", ")", "{", "addSummaryComment", "(", "element", ",", "utils", ".", "getFirstSentenceTrees", "(", "element", ")", ",", "htmltree", ")", ";", "}" ]

[ "Adds", "the", "summary", "content", "." ]

[ "private", "StringBuilder", "appendMapAsString", "(", "StringBuilder", "messageBuilder", ",", "Map", "<", "String", ",", "Object", ">", "map", ")", "{", "for", "(", "Entry", "<", "String", ",", "Object", ">", "mapEntry", ":", "map", ".", "entrySet", "(", ")", ")", "{", "Object", "headerValue", "=", "mapEntry", ".", "getValue", "(", ")", ";", "// Perform a case-insensitive check if the header should be scrubbed.", "if", "(", "SCRUBBED_HEADERS", ".", "contains", "(", "mapEntry", ".", "getKey", "(", ")", ".", "toLowerCase", "(", ")", ")", ")", "{", "headerValue", "=", "REDACTED_HEADER", ";", "}", "messageBuilder", ".", "append", "(", "String", ".", "format", "(", "\"%s: %s%n\"", ",", "mapEntry", ".", "getKey", "(", ")", ",", "headerValue", ")", ")", ";", "}", "return", "messageBuilder", ";", "}" ]

[ "Converts", "the", "map", "of", "key", "/", "value", "pairs", "to", "a", "multi", "-", "line", "string", "(", "one", "line", "per", "key", ")", ".", "Masks", "sensitive", "information", "for", "a", "predefined", "set", "of", "header", "keys", "." ]

[ "public", "static", "Properties", "readProperties", "(", "InputStream", "stream", ",", "Properties", "mappings", ",", "boolean", "closeStream", ")", "throws", "IOException", "{", "try", "{", "Properties", "p", "=", "new", "Properties", "(", ")", ";", "p", ".", "load", "(", "stream", ")", ";", "mappings", ".", "putAll", "(", "p", ")", ";", "boolean", "doAgain", "=", "true", ";", "while", "(", "doAgain", ")", "{", "doAgain", "=", "false", ";", "for", "(", "Map", ".", "Entry", "<", "Object", ",", "Object", ">", "entry", ":", "p", ".", "entrySet", "(", ")", ")", "{", "String", "value", "=", "(", "String", ")", "entry", ".", "getValue", "(", ")", ";", "if", "(", "value", ".", "indexOf", "(", "\"${\"", ")", ">=", "0", ")", "{", "value", "=", "resolveProperty", "(", "mappings", ",", "value", ")", ";", "entry", ".", "setValue", "(", "value", ")", ";", "doAgain", "=", "true", ";", "}", "}", "}", "return", "p", ";", "}", "finally", "{", "if", "(", "closeStream", ")", "{", "stream", ".", "close", "(", ")", ";", "}", "}", "}" ]

[ "Read", "a", "set", "of", "properties", "from", "a", "property", "file", "provided", "as", "an", "Inputstream", ".", "<p", "/", ">", "Property", "files", "may", "reference", "symbolic", "properties", "in", "the", "form", "$", "{", "name", "}", ".", "Translations", "occur", "from", "both", "the", "<code", ">", "mappings<", "/", "code", ">", "properties", "as", "well", "as", "all", "values", "within", "the", "Properties", "that", "are", "being", "read", ".", "<", "/", "p", ">", "<p", "/", ">", "Example", ";", "<", "/", "p", ">", "<code", ">", "<pre", ">", "Properties", "mappings", "=", "System", ".", "getProperties", "()", ";", "Properties", "myProps", "=", "PropertiesUtils", ".", "readProperties", "(", "mine", ".", "properties", "mappings", ")", ";", "<", "/", "pre", ">", "<", "/", "code", ">", "<p", "/", ">", "and", "the", "mine", ".", "properties", "file", "contains", ";", "<", "/", "p", ">", "<code", ">", "<pre", ">", "mything", "=", "$", "{", "myplace", "}", "/", "mything", "myplace", "=", "$", "{", "user", ".", "home", "}", "/", "myplace", "<", "/", "pre", ">", "<", "/", "code", ">", "<p", "/", ">", "then", "the", "Properties", "object", "<i", ">", "myProps<", "/", "i", ">", "will", "contain", ";", "<", "/", "p", ">", "<code", ">", "<pre", ">", "mything", "=", "/", "home", "/", "niclas", "/", "myplace", "/", "mything", "myplace", "=", "/", "home", "/", "niclas", "/", "myplace", "<", "/", "pre", ">", "<", "/", "code", ">" ]

[ "public", "static", "Object", "toJava", "(", "JSON", "json", ",", "JsonConfig", "jsonConfig", ")", "{", "if", "(", "JSONUtils", ".", "isNull", "(", "json", ")", ")", "{", "return", "null", ";", "}", "Object", "object", "=", "null", ";", "if", "(", "json", "instanceof", "JSONArray", ")", "{", "if", "(", "jsonConfig", ".", "getArrayMode", "(", ")", "==", "JsonConfig", ".", "MODE_OBJECT_ARRAY", ")", "{", "object", "=", "JSONArray", ".", "toArray", "(", "(", "JSONArray", ")", "json", ",", "jsonConfig", ")", ";", "}", "else", "{", "object", "=", "JSONArray", ".", "toCollection", "(", "(", "JSONArray", ")", "json", ",", "jsonConfig", ")", ";", "}", "}", "else", "{", "object", "=", "JSONObject", ".", "toBean", "(", "(", "JSONObject", ")", "json", ",", "jsonConfig", ")", ";", "}", "return", "object", ";", "}" ]

[ "Transform", "a", "JSON", "value", "to", "a", "java", "object", ".", "<br", ">", "Depending", "on", "the", "configured", "values", "for", "conversion", "this", "will", "return", "a", "DynaBean", "a", "bean", "a", "List", "or", "and", "array", "." ]

[ "public", "Long", "queryLong", "(", "String", "paramName", ",", "Long", "defaultValue", ")", "{", "return", "this", ".", "request", ".", "queryLong", "(", "paramName", ",", "defaultValue", ")", ";", "}" ]

[ "Returns", "a", "request", "parameter", "for", "a", "Long", "type" ]

[ "protected", "double", "getDoubleValue", "(", ")", "throws", "LazyException", "{", "double", "d", "=", "0.0", ";", "String", "str", "=", "getStringValue", "(", ")", ";", "try", "{", "d", "=", "Double", ".", "parseDouble", "(", "str", ")", ";", "}", "catch", "(", "NumberFormatException", "nfe", ")", "{", "// This basically can't happen since we already validate the numeric format when parsing", "// throw new LazyException(\"'\"+str+\"' is not a valid double\",startIndex);", "}", "return", "d", ";", "}" ]

[ "Parses", "the", "characters", "of", "this", "token", "and", "attempts", "to", "construct", "a", "double", "value", "from", "them", "." ]

[ "public", "Iterable", "<", "DUser", ">", "queryByAddress2", "(", "java", ".", "lang", ".", "String", "address2", ")", "{", "return", "queryByField", "(", "null", ",", "DUserMapper", ".", "Field", ".", "ADDRESS2", ".", "getFieldName", "(", ")", ",", "address2", ")", ";", "}" ]

[ "query", "-", "by", "method", "for", "field", "address2" ]

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

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

[ "public", "static", "HttpHandler", "getNext", "(", "HttpServerExchange", "httpServerExchange", ",", "HttpHandler", "next", ")", "throws", "Exception", "{", "if", "(", "next", "!=", "null", ")", "{", "return", "next", ";", "}", "return", "getNext", "(", "httpServerExchange", ")", ";", "}" ]

[ "Returns", "the", "instance", "of", "the", "next", "handler", "or", "the", "given", "next", "param", "if", "it", "s", "not", "null", "." ]

[ "public", "void", "getData", "(", "final", "String", "path", ",", "Watcher", "watcher", ",", "DataCallback", "cb", ",", "Object", "ctx", ")", "{", "verbotenThreadCheck", "(", ")", ";", "final", "String", "clientPath", "=", "path", ";", "PathUtils", ".", "validatePath", "(", "clientPath", ")", ";", "// the watch contains the un-chroot path", "WatchRegistration", "wcb", "=", "null", ";", "if", "(", "watcher", "!=", "null", ")", "{", "wcb", "=", "new", "DataWatchRegistration", "(", "watcher", ",", "clientPath", ")", ";", "}", "final", "String", "serverPath", "=", "prependChroot", "(", "clientPath", ")", ";", "RequestHeader", "h", "=", "new", "RequestHeader", "(", ")", ";", "h", ".", "setType", "(", "ZooDefs", ".", "OpCode", ".", "getData", ")", ";", "GetDataRequest", "request", "=", "new", "GetDataRequest", "(", ")", ";", "request", ".", "setPath", "(", "serverPath", ")", ";", "request", ".", "setWatch", "(", "watcher", "!=", "null", ")", ";", "GetDataResponse", "response", "=", "new", "GetDataResponse", "(", ")", ";", "cnxn", ".", "queuePacket", "(", "h", ",", "new", "ReplyHeader", "(", ")", ",", "request", ",", "response", ",", "cb", ",", "clientPath", ",", "serverPath", ",", "ctx", ",", "wcb", ")", ";", "}" ]

[ "The", "Asynchronous", "version", "of", "getData", ".", "The", "request", "doesn", "t", "actually", "until", "the", "asynchronous", "callback", "is", "called", "." ]

[ "private", "static", "boolean", "isRWLock", "(", "GuardedByExpression", "guard", ",", "VisitorState", "state", ")", "{", "Type", "guardType", "=", "guard", ".", "type", "(", ")", ";", "if", "(", "guardType", "==", "null", ")", "{", "return", "false", ";", "}", "Symbol", "rwLockSymbol", "=", "state", ".", "getSymbolFromString", "(", "JUC_READ_WRITE_LOCK", ")", ";", "if", "(", "rwLockSymbol", "==", "null", ")", "{", "return", "false", ";", "}", "return", "state", ".", "getTypes", "(", ")", ".", "isSubtype", "(", "guardType", ",", "rwLockSymbol", ".", "type", ")", ";", "}" ]

[ "Returns", "true", "if", "the", "lock", "expression", "corresponds", "to", "a", "{" ]

[ "public", "String", "replaceFrom", "(", "CharSequence", "sequence", ",", "CharSequence", "replacement", ")", "{", "return", "replaceFrom", "(", "sequence", ",", "replacement", ",", "CountMethod", ".", "MIN_ELEMENTS", ",", "SpanCondition", ".", "SIMPLE", ")", ";", "}" ]

[ "Replace", "all", "matching", "spans", "in", "sequence", "by", "the", "replacement", "counting", "by", "CountMethod", ".", "MIN_ELEMENTS", "using", "SpanCondition", ".", "SIMPLE", ".", "The", "code", "alternates", "spans", ";", "see", "the", "class", "doc", "for", "{" ]

[ "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "public", "<", "T", ">", "T", "fromJson", "(", "Reader", "json", ",", "Type", "typeOfT", ")", "throws", "JsonIOException", ",", "JsonSyntaxException", "{", "JsonReader", "jsonReader", "=", "newJsonReader", "(", "json", ")", ";", "T", "object", "=", "(", "T", ")", "fromJson", "(", "jsonReader", ",", "typeOfT", ")", ";", "assertFullConsumption", "(", "object", ",", "jsonReader", ")", ";", "return", "object", ";", "}" ]

[ "This", "method", "deserializes", "the", "Json", "read", "from", "the", "specified", "reader", "into", "an", "object", "of", "the", "specified", "type", ".", "This", "method", "is", "useful", "if", "the", "specified", "object", "is", "a", "generic", "type", ".", "For", "non", "-", "generic", "objects", "use", "{", "@link", "#fromJson", "(", "Reader", "Class", ")", "}", "instead", ".", "If", "you", "have", "the", "Json", "in", "a", "String", "form", "instead", "of", "a", "{", "@link", "Reader", "}", "use", "{", "@link", "#fromJson", "(", "String", "Type", ")", "}", "instead", "." ]

[ "@", "Deprecated", "public", "ClientConfig", "setNodeBannagePeriod", "(", "int", "nodeBannagePeriod", ",", "TimeUnit", "unit", ")", "{", "this", ".", "failureDetectorBannagePeriod", "=", "unit", ".", "toMillis", "(", "nodeBannagePeriod", ")", ";", "return", "this", ";", "}" ]

[ "The", "period", "of", "time", "to", "ban", "a", "node", "that", "gives", "an", "error", "on", "an", "operation", "." ]

[ "public", "String", "createAuthzHeaderForRequestTokenEndpoint", "(", "String", "callbackUrl", ",", "String", "endpointUrl", ")", "{", "Map", "<", "String", ",", "String", ">", "parameters", "=", "populateRequestTokenEndpointAuthzHeaderParams", "(", "callbackUrl", ")", ";", "return", "signAndCreateAuthzHeader", "(", "endpointUrl", ",", "parameters", ")", ";", "}" ]

[ "Generates", "the", "Authorization", "header", "value", "required", "for", "a", "{", "@value", "TwitterConstants#TWITTER_ENDPOINT_REQUEST_TOKEN", "}", "endpoint", "request", ".", "See", "{", "@link", "https", ":", "//", "dev", ".", "twitter", ".", "com", "/", "oauth", "/", "reference", "/", "post", "/", "oauth", "/", "request_token", "}", "for", "details", "." ]

[ "private", "static", "void", "addPanels", "(", "TabbedPanel2", "tabbedPanel", ",", "List", "<", "AbstractPanel", ">", "panels", ",", "boolean", "visible", ")", "{", "for", "(", "AbstractPanel", "panel", ":", "panels", ")", "{", "addPanel", "(", "tabbedPanel", ",", "panel", ",", "visible", ")", ";", "}", "tabbedPanel", ".", "revalidate", "(", ")", ";", "}" ]

[ "Adds", "the", "given", "{", "@code", "panels", "}", "to", "the", "given", "{", "@code", "tabbedPanel", "}", "and", "whether", "they", "should", "be", "visible", ".", "<p", ">", "After", "adding", "all", "the", "panels", "the", "tabbed", "panel", "is", "revalidated", "." ]

[ "public", "static", "BigtableInstanceAdminClient", "create", "(", "@", "Nonnull", "String", "projectId", ",", "@", "Nonnull", "BigtableInstanceAdminStub", "stub", ")", "{", "return", "new", "BigtableInstanceAdminClient", "(", "projectId", ",", "stub", ")", ";", "}" ]

[ "Constructs", "an", "instance", "of", "BigtableInstanceAdminClient", "with", "the", "given", "project", "id", "and", "stub", "." ]

[ "public", "static", "<", "E", ">", "DoubleStream", "shiftingWindowAveragingDouble", "(", "Stream", "<", "E", ">", "stream", ",", "int", "rollingFactor", ",", "ToDoubleFunction", "<", "?", "super", "E", ">", "mapper", ")", "{", "Objects", ".", "requireNonNull", "(", "stream", ")", ";", "Objects", ".", "requireNonNull", "(", "mapper", ")", ";", "DoubleStream", "doubleStream", "=", "stream", ".", "mapToDouble", "(", "mapper", ")", ";", "return", "shiftingWindowAveragingDouble", "(", "doubleStream", ",", "rollingFactor", ")", ";", "}" ]

[ "<p", ">", "Generates", "a", "stream", "that", "is", "computed", "from", "a", "provided", "stream", "following", "two", "steps", ".", "<", "/", "p", ">", "<p", ">", "The", "first", "steps", "maps", "this", "stream", "to", "an", "<code", ">", "DoubleStream<", "/", "code", ">", "that", "is", "then", "rolled", "following", "the", "same", "principle", "as", "the", "<code", ">", "roll", "()", "<", "/", "code", ">", "method", ".", "This", "steps", "builds", "a", "<code", ">", "Stream&lt", ";", "DoubleStream&gt", ";", "<", "/", "code", ">", ".", "<", "/", "p", ">", "<p", ">", "Then", "the", "<code", ">", "average", "()", "<", "/", "code", ">", "method", "is", "called", "on", "each", "<code", ">", "DoubleStream<", "/", "code", ">", "using", "a", "mapper", "and", "a", "<code", ">", "DoubleStream<", "/", "code", ">", "of", "averages", "is", "returned", ".", "<", "/", "p", ">", "<p", ">", "The", "resulting", "stream", "has", "the", "same", "number", "of", "elements", "as", "the", "provided", "stream", "minus", "the", "size", "of", "the", "window", "width", "to", "preserve", "consistency", "of", "each", "collection", ".", "<", "/", "p", ">", "<p", ">", "A", "<code", ">", "NullPointerException<", "/", "code", ">", "will", "be", "thrown", "if", "the", "provided", "stream", "or", "the", "mapper", "is", "null", ".", "<", "/", "p", ">" ]

[ "private", "boolean", "writeToCharacteristic", "(", "BluetoothGattCharacteristic", "charc", ",", "byte", "[", "]", "data", ")", "{", "charc", ".", "setValue", "(", "data", ")", ";", "boolean", "result", "=", "mGattClient", ".", "writeCharacteristic", "(", "charc", ")", ";", "if", "(", "result", ")", "{", "Log", ".", "d", "(", "TAG", ",", "\"Wrote to characteristic: \"", "+", "charc", ".", "getUuid", "(", ")", "+", "\", data: \"", "+", "Arrays", ".", "toString", "(", "data", ")", ")", ";", "}", "else", "{", "Log", ".", "e", "(", "TAG", ",", "\"Write failed to characteristic: \"", "+", "charc", ".", "getUuid", "(", ")", "+", "\", data: \"", "+", "Arrays", ".", "toString", "(", "data", ")", ")", ";", "}", "return", "result", ";", "}" ]

[ "Write", "to", "a", "OAD", "characteristic" ]

[ "@", "SuppressWarnings", "(", "\"Guava\"", ")", "public", "T", "retryOnException", "(", "Supplier", "<", "T", ">", "supplierCommand", ",", "Predicate", "<", "Throwable", ">", "throwablePredicate", ",", "Predicate", "<", "T", ">", "resultRetryPredicate", ",", "int", "retryCount", ",", "String", "shortDescription", ",", "String", "operationName", ")", "throws", "RuntimeException", "{", "Retryer", "<", "T", ">", "retryer", "=", "RetryerBuilder", ".", "<", "T", ">", "newBuilder", "(", ")", ".", "retryIfException", "(", "Optional", ".", "ofNullable", "(", "throwablePredicate", ")", ".", "orElse", "(", "exception", "->", "true", ")", ")", ".", "retryIfResult", "(", "Optional", ".", "ofNullable", "(", "resultRetryPredicate", ")", ".", "orElse", "(", "result", "->", "false", ")", ")", ".", "withWaitStrategy", "(", "WaitStrategies", ".", "join", "(", "WaitStrategies", ".", "exponentialWait", "(", "1000", ",", "90", ",", "TimeUnit", ".", "SECONDS", ")", ",", "WaitStrategies", ".", "randomWait", "(", "100", ",", "TimeUnit", ".", "MILLISECONDS", ",", "500", ",", "TimeUnit", ".", "MILLISECONDS", ")", ")", ")", ".", "withStopStrategy", "(", "StopStrategies", ".", "stopAfterAttempt", "(", "retryCount", ")", ")", ".", "withBlockStrategy", "(", "BlockStrategies", ".", "threadSleepStrategy", "(", ")", ")", ".", "withRetryListener", "(", "new", "RetryListener", "(", ")", "{", "@", "Override", "public", "<", "V", ">", "void", "onRetry", "(", "Attempt", "<", "V", ">", "attempt", ")", "{", "logger", ".", "debug", "(", "\"Attempt # {}, {} millis since first attempt. Operation: {}, description:{}\"", ",", "attempt", ".", "getAttemptNumber", "(", ")", ",", "attempt", ".", "getDelaySinceFirstAttempt", "(", ")", ",", "operationName", ",", "shortDescription", ")", ";", "internalNumberOfRetries", ".", "incrementAndGet", "(", ")", ";", "}", "}", ")", ".", "build", "(", ")", ";", "try", "{", "return", "retryer", ".", "call", "(", "supplierCommand", "::", "get", ")", ";", "}", "catch", "(", "ExecutionException", "executionException", ")", "{", "String", "errorMessage", "=", "String", ".", "format", "(", "\"Operation '%s:%s' failed for the %d time in RetryUtil\"", ",", "operationName", ",", "shortDescription", ",", "internalNumberOfRetries", ".", "get", "(", ")", ")", ";", "logger", ".", "debug", "(", "errorMessage", ")", ";", "throw", "new", "RuntimeException", "(", "errorMessage", ",", "executionException", ".", "getCause", "(", ")", ")", ";", "}", "catch", "(", "RetryException", "retryException", ")", "{", "String", "errorMessage", "=", "String", ".", "format", "(", "\"Operation '%s:%s' failed after retrying %d times, retry limit %d\"", ",", "operationName", ",", "shortDescription", ",", "internalNumberOfRetries", ".", "get", "(", ")", ",", "3", ")", ";", "logger", ".", "debug", "(", "errorMessage", ",", "retryException", ".", "getLastFailedAttempt", "(", ")", ".", "getExceptionCause", "(", ")", ")", ";", "throw", "new", "RuntimeException", "(", "errorMessage", ",", "retryException", ".", "getLastFailedAttempt", "(", ")", ".", "getExceptionCause", "(", ")", ")", ";", "}", "}" ]

[ "A", "helper", "method", "which", "has", "the", "ability", "to", "execute", "a", "flaky", "supplier", "function", "and", "retry", "in", "case", "of", "failures", "." ]

[ "public", "static", "String", "read", "(", "ReadableByteChannel", "channel", ",", "Charset", "charset", ")", "throws", "IORuntimeException", "{", "FastByteArrayOutputStream", "out", "=", "read", "(", "channel", ")", ";", "return", "null", "==", "charset", "?", "out", ".", "toString", "(", ")", ":", "out", ".", "toString", "(", "charset", ")", ";", "}" ]

[ "从流中读取内容，读取完毕后并不关闭流" ]

[ "public", "static", "void", "configureGenerator", "(", "UriInfo", "uriInfo", ",", "JsonGenerator", "generator", ",", "boolean", "isDev", ")", "{", "MultivaluedMap", "<", "String", ",", "String", ">", "params", "=", "uriInfo", ".", "getQueryParameters", "(", ")", ";", "String", "pretty", "=", "params", ".", "getFirst", "(", "\"pretty\"", ")", ";", "if", "(", "\"false\"", ".", "equalsIgnoreCase", "(", "pretty", ")", ")", "{", "generator", ".", "setPrettyPrinter", "(", "null", ")", ";", "}", "else", "if", "(", "pretty", "!=", "null", "&&", "!", "\"false\"", ".", "equalsIgnoreCase", "(", "pretty", ")", "||", "isDev", ")", "{", "generator", ".", "useDefaultPrettyPrinter", "(", ")", ";", "}", "String", "unicode", "=", "params", ".", "getFirst", "(", "\"unicode\"", ")", ";", "if", "(", "unicode", "!=", "null", "&&", "!", "\"false\"", ".", "equalsIgnoreCase", "(", "unicode", ")", ")", "{", "generator", ".", "enable", "(", "JsonGenerator", ".", "Feature", ".", "ESCAPE_NON_ASCII", ")", ";", "}", "}" ]

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

[ "public", "Object", "createSessionLoginToken", "(", "Map", "<", "String", ",", "Object", ">", "queryParams", ")", "throws", "OAuthSystemException", ",", "OAuthProblemException", ",", "URISyntaxException", "{", "return", "createSessionLoginToken", "(", "queryParams", ",", "null", ")", ";", "}" ]

[ "Generate", "a", "session", "login", "token", "in", "scenarios", "in", "which", "MFA", "may", "or", "may", "not", "be", "required", ".", "A", "session", "login", "token", "expires", "two", "minutes", "after", "creation", "." ]

[ "public", "void", "fixupVariables", "(", "java", ".", "util", ".", "Vector", "vars", ",", "int", "globalsSize", ")", "{", "(", "(", "Expression", ")", "m_obj", ")", ".", "fixupVariables", "(", "vars", ",", "globalsSize", ")", ";", "}" ]

[ "This", "function", "is", "used", "to", "fixup", "variables", "from", "QNames", "to", "stack", "frame", "indexes", "at", "stylesheet", "build", "time", "." ]

[ "public", "java", ".", "util", ".", "List", "<", "String", ">", "getStatusList", "(", ")", "{", "if", "(", "statusList", "==", "null", ")", "{", "statusList", "=", "new", "com", ".", "amazonaws", ".", "internal", ".", "SdkInternalList", "<", "String", ">", "(", ")", ";", "}", "return", "statusList", ";", "}" ]

[ "<p", ">", "An", "array", "of", "domain", "name", "status", "codes", "also", "known", "as", "Extensible", "Provisioning", "Protocol", "(", "EPP", ")", "status", "codes", ".", "<", "/", "p", ">", "<p", ">", "ICANN", "the", "organization", "that", "maintains", "a", "central", "database", "of", "domain", "names", "has", "developed", "a", "set", "of", "domain", "name", "status", "codes", "that", "tell", "you", "the", "status", "of", "a", "variety", "of", "operations", "on", "a", "domain", "name", "for", "example", "registering", "a", "domain", "name", "transferring", "a", "domain", "name", "to", "another", "registrar", "renewing", "the", "registration", "for", "a", "domain", "name", "and", "so", "on", ".", "All", "registrars", "use", "this", "same", "set", "of", "status", "codes", ".", "<", "/", "p", ">", "<p", ">", "For", "a", "current", "list", "of", "domain", "name", "status", "codes", "and", "an", "explanation", "of", "what", "each", "code", "means", "go", "to", "the", "<a", "href", "=", "https", ":", "//", "www", ".", "icann", ".", "org", "/", ">", "ICANN", "website<", "/", "a", ">", "and", "search", "for", "<code", ">", "epp", "status", "codes<", "/", "code", ">", ".", "(", "Search", "on", "the", "ICANN", "website", ";", "web", "searches", "sometimes", "return", "an", "old", "version", "of", "the", "document", ".", ")", "<", "/", "p", ">" ]

[ "@", "Override", "public", "List", "<", "CPInstance", ">", "findByLtD_S", "(", "Date", "displayDate", ",", "int", "status", ",", "int", "start", ",", "int", "end", ")", "{", "return", "findByLtD_S", "(", "displayDate", ",", "status", ",", "start", ",", "end", ",", "null", ")", ";", "}" ]

[ "Returns", "a", "range", "of", "all", "the", "cp", "instances", "where", "displayDate", "&lt", ";", "&#63", ";", "and", "status", "=", "&#63", ";", "." ]

[ "@", "Reference", "(", "authors", "=", "\"F. J. Rohlf\"", ",", "title", "=", "\"Methods of comparing classifications\"", ",", "//", "booktitle", "=", "\"Annual Review of Ecology and Systematics\"", ",", "//", "url", "=", "\"https://doi.org/10.1146/annurev.es.05.110174.000533\"", ",", "//", "bibkey", "=", "\"doi:10.1146/annurev.es.05.110174.000533\"", ")", "public", "double", "computeTau", "(", "long", "c", ",", "long", "d", ",", "double", "m", ",", "long", "wd", ",", "long", "bd", ")", "{", "double", "tie", "=", "(", "wd", "*", "(", "wd", "-", "1", ")", "+", "bd", "*", "(", "bd", "-", "1", ")", ")", ">>>", "1", ";", "return", "(", "c", "-", "d", ")", "/", "FastMath", ".", "sqrt", "(", "(", "m", "-", "tie", ")", "*", "m", ")", ";", "// return (4. * c - m) / m;", "}" ]

[ "Compute", "the", "Tau", "correlation", "measure" ]

[ "private", "void", "encodeHiddenInputs", "(", "final", "ResponseWriter", "responseWriter", ",", "final", "Sheet", "sheet", ",", "final", "String", "clientId", ")", "throws", "IOException", "{", "responseWriter", ".", "startElement", "(", "\"input\"", ",", "null", ")", ";", "responseWriter", ".", "writeAttribute", "(", "\"id\"", ",", "clientId", "+", "\"_input\"", ",", "\"id\"", ")", ";", "responseWriter", ".", "writeAttribute", "(", "\"name\"", ",", "clientId", "+", "\"_input\"", ",", "\"name\"", ")", ";", "responseWriter", ".", "writeAttribute", "(", "\"type\"", ",", "\"hidden\"", ",", "null", ")", ";", "responseWriter", ".", "writeAttribute", "(", "\"value\"", ",", "\"\"", ",", "null", ")", ";", "responseWriter", ".", "endElement", "(", "\"input\"", ")", ";", "responseWriter", ".", "startElement", "(", "\"input\"", ",", "null", ")", ";", "responseWriter", ".", "writeAttribute", "(", "\"id\"", ",", "clientId", "+", "\"_focus\"", ",", "\"id\"", ")", ";", "responseWriter", ".", "writeAttribute", "(", "\"name\"", ",", "clientId", "+", "\"_focus\"", ",", "\"name\"", ")", ";", "responseWriter", ".", "writeAttribute", "(", "\"type\"", ",", "\"hidden\"", ",", "null", ")", ";", "if", "(", "sheet", ".", "getFocusId", "(", ")", "==", "null", ")", "{", "responseWriter", ".", "writeAttribute", "(", "\"value\"", ",", "\"\"", ",", "null", ")", ";", "}", "else", "{", "responseWriter", ".", "writeAttribute", "(", "\"value\"", ",", "sheet", ".", "getFocusId", "(", ")", ",", "null", ")", ";", "}", "responseWriter", ".", "endElement", "(", "\"input\"", ")", ";", "responseWriter", ".", "startElement", "(", "\"input\"", ",", "null", ")", ";", "responseWriter", ".", "writeAttribute", "(", "\"id\"", ",", "clientId", "+", "\"_selection\"", ",", "\"id\"", ")", ";", "responseWriter", ".", "writeAttribute", "(", "\"name\"", ",", "clientId", "+", "\"_selection\"", ",", "\"name\"", ")", ";", "responseWriter", ".", "writeAttribute", "(", "\"type\"", ",", "\"hidden\"", ",", "null", ")", ";", "if", "(", "sheet", ".", "getSelection", "(", ")", "==", "null", ")", "{", "responseWriter", ".", "writeAttribute", "(", "\"value\"", ",", "\"\"", ",", "null", ")", ";", "}", "else", "{", "responseWriter", ".", "writeAttribute", "(", "\"value\"", ",", "sheet", ".", "getSelection", "(", ")", ",", "null", ")", ";", "}", "responseWriter", ".", "endElement", "(", "\"input\"", ")", ";", "// sort col and order if specified and supported", "final", "int", "sortCol", "=", "sheet", ".", "getSortColRenderIndex", "(", ")", ";", "responseWriter", ".", "startElement", "(", "\"input\"", ",", "null", ")", ";", "responseWriter", ".", "writeAttribute", "(", "\"id\"", ",", "clientId", "+", "\"_sortby\"", ",", "\"id\"", ")", ";", "responseWriter", ".", "writeAttribute", "(", "\"name\"", ",", "clientId", "+", "\"_sortby\"", ",", "\"name\"", ")", ";", "responseWriter", ".", "writeAttribute", "(", "\"type\"", ",", "\"hidden\"", ",", "null", ")", ";", "responseWriter", ".", "writeAttribute", "(", "\"value\"", ",", "sortCol", ",", "null", ")", ";", "responseWriter", ".", "endElement", "(", "\"input\"", ")", ";", "responseWriter", ".", "startElement", "(", "\"input\"", ",", "null", ")", ";", "responseWriter", ".", "writeAttribute", "(", "\"id\"", ",", "clientId", "+", "\"_sortorder\"", ",", "\"id\"", ")", ";", "responseWriter", ".", "writeAttribute", "(", "\"name\"", ",", "clientId", "+", "\"_sortorder\"", ",", "\"name\"", ")", ";", "responseWriter", ".", "writeAttribute", "(", "\"type\"", ",", "\"hidden\"", ",", "null", ")", ";", "responseWriter", ".", "writeAttribute", "(", "\"value\"", ",", "sheet", ".", "getSortOrder", "(", ")", ".", "toLowerCase", "(", ")", ",", "null", ")", ";", "responseWriter", ".", "endElement", "(", "\"input\"", ")", ";", "}" ]

[ "Encode", "hidden", "input", "fields" ]

[ "private", "void", "setTypes", "(", "int", "start", ",", "int", "limit", ",", "byte", "newType", ")", "{", "for", "(", "int", "i", "=", "start", ";", "i", "<", "limit", ";", "++", "i", ")", "{", "resultTypes", "[", "i", "]", "=", "newType", ";", "}", "}" ]

[ "Set", "resultTypes", "from", "start", "up", "to", "(", "but", "not", "including", ")", "limit", "to", "newType", "." ]