Datasets:

stojchet

/

csn_java_python_subset

like 0

[ "private", "static", "long", "timetMillisFromEpochSecs", "(", "long", "epochSecs", ",", "TimeZone", "zone", ")", "{", "DateTimeValue", "date", "=", "timeFromSecsSinceEpoch", "(", "epochSecs", ")", ";", "Calendar", "cal", "=", "new", "GregorianCalendar", "(", "zone", ")", ";", "cal", ".", "clear", "(", ")", ";", "cal", ".", "set", "(", "date", ".", "year", "(", ")", ",", "date", ".", "month", "(", ")", "-", "1", ",", "date", ".", "day", "(", ")", ",", "date", ".", "hour", "(", ")", ",", "date", ".", "minute", "(", ")", ",", "date", ".", "second", "(", ")", ")", ";", "return", "cal", ".", "getTimeInMillis", "(", ")", ";", "}" ]

[ "Get", "a", "time_t", "in", "milliseconds", "given", "a", "number", "of", "seconds", "since", "the", "Dershowitz", "/", "Reingold", "epoch", "relative", "to", "a", "given", "timezone", "." ]

[ "public", "void", "addInt8", "(", "final", "int", "key", ",", "final", "byte", "b", ")", "{", "PebbleTuple", "t", "=", "PebbleTuple", ".", "create", "(", "key", ",", "PebbleTuple", ".", "TupleType", ".", "INT", ",", "PebbleTuple", ".", "Width", ".", "BYTE", ",", "b", ")", ";", "addTuple", "(", "t", ")", ";", "}" ]

[ "Associate", "the", "specified", "signed", "byte", "with", "the", "provided", "key", "in", "the", "dictionary", ".", "If", "another", "key", "-", "value", "pair", "with", "the", "same", "key", "is", "already", "present", "in", "the", "dictionary", "it", "will", "be", "replaced", "." ]

[ "private", "ResultItem", "pollResultItem", "(", "long", "timeout", ",", "boolean", "idle", ")", "{", "ResultItem", "result", "=", "getResult", "(", ")", ";", "if", "(", "result", "!=", "null", ")", "{", "result", ".", "remainingIdleTimeout", "=", "timeout", ";", "}", "if", "(", "result", "==", "null", "&&", "timeout", ">", "0", ")", "{", "long", "start", "=", "System", ".", "currentTimeMillis", "(", ")", ";", "internalWait", "(", "timeout", ")", ";", "long", "end", "=", "System", ".", "currentTimeMillis", "(", ")", ";", "result", "=", "getResult", "(", ")", ";", "if", "(", "result", "!=", "null", ")", "{", "result", ".", "remainingIdleTimeout", "=", "timeout", "-", "(", "end", "-", "start", ")", ";", "logger", ".", "finest", "(", "\"Remaining timeout: \"", "+", "result", ".", "remainingIdleTimeout", ")", ";", "}", "}", "if", "(", "result", "==", "null", ")", "{", "if", "(", "idle", ")", "{", "throw", "new", "ResponseNotReceivedException", "(", "\"No idle response in a timely fashion\"", ")", ";", "}", "else", "{", "throw", "new", "ResponseNotReceivedException", "(", "\"No response in a timely fashion\"", ")", ";", "}", "}", "return", "result", ";", "}" ]

[ "Checks", "for", "a", "result", "item", ".", "<p", "/", ">", "If", "no", "result", "item", "is", "available", "this", "method", "will", "wait", "for", "timeout", "milliseconds", "and", "try", "again", ".", "If", "still", "no", "result", "if", "available", "then", "a", "ResponseNotReceivedException", "is", "thrown", "." ]

[ "public", "SqlStatement", "getPreparedDeleteStatement", "(", "Query", "query", ",", "ClassDescriptor", "cld", ")", "{", "return", "new", "SqlDeleteByQuery", "(", "m_platform", ",", "cld", ",", "query", ",", "logger", ")", ";", "}" ]

[ "generate", "a", "prepared", "DELETE", "-", "Statement", "according", "to", "query" ]

[ "public", "static", "Iban", "valueOf", "(", "final", "String", "iban", ",", "final", "IbanFormat", "format", ")", "throws", "IbanFormatException", ",", "InvalidCheckDigitException", ",", "UnsupportedCountryException", "{", "switch", "(", "format", ")", "{", "case", "Default", ":", "final", "String", "ibanWithoutSpaces", "=", "iban", ".", "replace", "(", "\" \"", ",", "\"\"", ")", ";", "final", "Iban", "ibanObj", "=", "valueOf", "(", "ibanWithoutSpaces", ")", ";", "if", "(", "ibanObj", ".", "toFormattedString", "(", ")", ".", "equals", "(", "iban", ")", ")", "{", "return", "ibanObj", ";", "}", "throw", "new", "IbanFormatException", "(", "IBAN_FORMATTING", ",", "String", ".", "format", "(", "\"Iban must be formatted using 4 characters and space combination. \"", "+", "\"Instead of [%s]\"", ",", "iban", ")", ")", ";", "default", ":", "return", "valueOf", "(", "iban", ")", ";", "}", "}" ]

[ "Returns", "an", "Iban", "object", "holding", "the", "value", "of", "the", "specified", "String", "." ]

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

[ "Returns", "a", "range", "of", "all", "the", "commerce", "tax", "fixed", "rate", "address", "rels", "." ]

[ "public", "void", "setValues", "(", "List", "<", "T", ">", "values", ",", "boolean", "fireEvents", ")", "{", "String", "[", "]", "stringValues", "=", "new", "String", "[", "values", ".", "size", "(", ")", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "values", ".", "size", "(", ")", ";", "i", "++", ")", "{", "stringValues", "[", "i", "]", "=", "keyFactory", ".", "generateKey", "(", "values", ".", "get", "(", "i", ")", ")", ";", "}", "suppressChangeEvent", "=", "!", "fireEvents", ";", "$", "(", "listbox", ".", "getElement", "(", ")", ")", ".", "val", "(", "stringValues", ")", ".", "trigger", "(", "\"change\"", ",", "selectedIndex", ")", ";", "suppressChangeEvent", "=", "false", ";", "}" ]

[ "Set", "directly", "all", "the", "values", "that", "will", "be", "stored", "into", "combobox", "and", "build", "options", "into", "it", "." ]

[ "public", "static", "int", "setProtected", "(", "int", "modifier", ",", "boolean", "b", ")", "{", "if", "(", "b", ")", "{", "return", "(", "modifier", "|", "PROTECTED", ")", "&", "(", "~", "PUBLIC", "&", "~", "PRIVATE", ")", ";", "}", "else", "{", "return", "modifier", "&", "~", "PROTECTED", ";", "}", "}" ]

[ "When", "set", "protected", "the", "modifier", "is", "cleared", "from", "being", "public", "or", "private", "." ]

[ "public", "void", "accumulateBug", "(", "BugInstance", "bug", ",", "BytecodeScanningDetector", "visitor", ")", "{", "SourceLineAnnotation", "source", "=", "SourceLineAnnotation", ".", "fromVisitedInstruction", "(", "visitor", ")", ";", "accumulateBug", "(", "bug", ",", "source", ")", ";", "}" ]

[ "Accumulate", "a", "warning", "at", "source", "location", "currently", "being", "visited", "by", "given", "BytecodeScanningDetector", "." ]

[ "public", "void", "logp", "(", "Level", "level", ",", "String", "sourceClass", ",", "String", "sourceMethod", ",", "String", "msg", ")", "{", "delegateLogger", ".", "logp", "(", "level", ",", "sourceClass", ",", "sourceMethod", ",", "msg", ")", ";", "}" ]

[ "Override", "every", "method", "from", "Logger", "to", "be", "called", "on", "the", "delegateLogger", "." ]

[ "protected", "void", "sendRequests", "(", ")", "{", "if", "(", "!", "requestUnderway", ")", "{", "requestUnderway", "=", "true", ";", "delayed", "(", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "synchronized", "(", "requests", ")", "{", "Object", "req", "[", "]", ";", "if", "(", "openFutureRequests", ".", "get", "(", ")", ">", "0", "&&", "requests", ".", "size", "(", ")", "==", "0", ")", "{", "req", "=", "new", "Object", "[", "]", "{", "\"SP\"", ",", "lastSeenSeq", "}", ";", "}", "else", "{", "req", "=", "new", "Object", "[", "requests", ".", "size", "(", ")", "+", "1", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "requests", ".", "size", "(", ")", ";", "i", "++", ")", "{", "req", "[", "i", "]", "=", "requests", ".", "get", "(", "i", ")", ";", "}", "req", "[", "req", ".", "length", "-", "1", "]", "=", "lastSeenSeq", ";", "requests", ".", "clear", "(", ")", ";", "}", "sendCallArray", "(", "req", ")", ".", "then", "(", "new", "Callback", "<", "Integer", ">", "(", ")", "{", "@", "Override", "public", "void", "receive", "(", "Integer", "result", ",", "Object", "error", ")", "{", "synchronized", "(", "requests", ")", "{", "requestUnderway", "=", "false", ";", "if", "(", "requests", ".", "size", "(", ")", ">", "0", "||", "(", "result", "!=", "null", "&&", "result", ">", "0", "&&", "openFutureRequests", ".", "get", "(", ")", ">", "0", ")", ")", "{", "myExec", ".", "execute", "(", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "sendRequests", "(", ")", ";", "}", "}", ")", ";", "}", "}", "}", "}", ")", ";", "}", "}", "}", ",", "1", ")", ";", "}", "}" ]

[ "sends", "pending", "requests", "async", ".", "needs", "be", "executed", "inside", "lock", "(", "see", "calls", "of", "this", ")" ]

[ "public", "Parameters", "setValue", "(", "@", "NonNull", "String", "name", ",", "Object", "value", ")", "{", "if", "(", "name", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"name cannot be null.\"", ")", ";", "}", "if", "(", "readonly", ")", "{", "throw", "new", "IllegalStateException", "(", "\"Parameters is readonly mode.\"", ")", ";", "}", "map", ".", "put", "(", "name", ",", "value", ")", ";", "return", "this", ";", "}" ]

[ "Set", "a", "value", "to", "the", "query", "parameter", "referenced", "by", "the", "given", "name", ".", "A", "query", "parameter", "is", "defined", "by", "using", "the", "Expression", "s", "parameter", "(", "String", "name", ")", "function", "." ]

[ "protected", "<", "T", ">", "T", "doPost", "(", "String", "path", ",", "MultivaluedMap", "<", "String", ",", "String", ">", "formParams", ",", "GenericType", "<", "T", ">", "genericType", ")", "throws", "ClientException", "{", "return", "doPost", "(", "path", ",", "formParams", ",", "genericType", ",", "null", ")", ";", "}" ]

[ "Submits", "a", "form", "and", "gets", "back", "a", "JSON", "object", ".", "Adds", "appropriate", "Accepts", "and", "Content", "Type", "headers", "." ]

[ "private", "void", "outputReportLine", "(", "List", "<", "String", ">", "report", ",", "MessageFormat", "template", ",", "String", "[", "]", "textLines", ",", "int", "currentLine", ")", "{", "Object", "[", "]", "_args", "=", "{", "currentLine", ",", "textLines", "[", "currentLine", "]", "}", ";", "report", ".", "add", "(", "template", ".", "format", "(", "_args", ")", ")", ";", "}" ]

[ "Add", "a", "report", "line", "the", "designated", "line", "." ]

[ "public", "static", "File", "writeObjectToTempFileNoExceptions", "(", "Object", "o", ",", "String", "filename", ")", "{", "try", "{", "return", "writeObjectToTempFile", "(", "o", ",", "filename", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "System", ".", "err", ".", "println", "(", "\"Error writing object to file \"", "+", "filename", ")", ";", "e", ".", "printStackTrace", "(", ")", ";", "return", "null", ";", "}", "}" ]

[ "Write", "object", "to", "a", "temp", "file", "and", "ignore", "exceptions", "." ]

[ "public", "<", "S", "extends", "AddressSegment", ">", "void", "getSplitSegments", "(", "S", "segs", "[", "]", ",", "int", "index", ",", "AddressSegmentCreator", "<", "S", ">", "creator", ")", "{", "if", "(", "!", "isMultiple", "(", ")", ")", "{", "int", "bitSizeSplit", "=", "IPv6Address", ".", "BITS_PER_SEGMENT", ">>>", "1", ";", "Integer", "myPrefix", "=", "getSegmentPrefixLength", "(", ")", ";", "Integer", "highPrefixBits", "=", "getSplitSegmentPrefix", "(", "bitSizeSplit", ",", "myPrefix", ",", "0", ")", ";", "Integer", "lowPrefixBits", "=", "getSplitSegmentPrefix", "(", "bitSizeSplit", ",", "myPrefix", ",", "1", ")", ";", "if", "(", "index", ">=", "0", "&&", "index", "<", "segs", ".", "length", ")", "{", "segs", "[", "index", "]", "=", "creator", ".", "createSegment", "(", "highByte", "(", ")", ",", "highPrefixBits", ")", ";", "}", "if", "(", "++", "index", ">=", "0", "&&", "index", "<", "segs", ".", "length", ")", "{", "segs", "[", "index", "]", "=", "creator", ".", "createSegment", "(", "lowByte", "(", ")", ",", "lowPrefixBits", ")", ";", "}", "}", "else", "{", "getSplitSegmentsMultiple", "(", "segs", ",", "index", ",", "creator", ")", ";", "}", "}" ]

[ "Converts", "this", "IPv6", "address", "segment", "into", "smaller", "segments", "copying", "them", "into", "the", "given", "array", "starting", "at", "the", "given", "index", "." ]

[ "public", "StringBuilder", "toMsg", "(", "StringBuilder", "sb", ",", "String", "attErrJson", ")", "throws", "APIException", "{", "return", "toMsg", "(", "sb", ",", "errDF", ".", "newData", "(", ")", ".", "in", "(", "TYPE", ".", "JSON", ")", ".", "load", "(", "attErrJson", ")", ".", "asObject", "(", ")", ")", ";", "}" ]

[ "AT&T", "Requires", "a", "specific", "Error", "Format", "for", "RESTful", "Services", "which", "AAF", "complies", "with", "." ]

[ "protected", "void", "requestAttributeChange", "(", "String", "name", ",", "Object", "value", ",", "Object", "oldValue", ")", "{", "requestAttributeChange", "(", "name", ",", "value", ",", "oldValue", ",", "Transport", ".", "DEFAULT", ")", ";", "}" ]

[ "Called", "by", "derived", "instances", "when", "an", "attribute", "setter", "method", "was", "called", "." ]

[ "public", "RgbaColor", "opacify", "(", "float", "amount", ")", "{", "return", "new", "RgbaColor", "(", "r", ",", "g", ",", "b", ",", "alphaCheck", "(", "a", "+", "amount", ")", ")", ";", "}" ]

[ "Returns", "a", "new", "color", "that", "has", "the", "alpha", "adjusted", "by", "the", "specified", "amount", "." ]

[ "@", "Override", "public", "Item", "process", "(", "Context", "context", ",", "CachingOptions", "cachingOptions", ",", "Item", "item", ")", "{", "for", "(", "String", "xpathQuery", ":", "metaDataNodesXPathQueries", ")", "{", "String", "metaDataValue", "=", "item", ".", "queryDescriptorValue", "(", "xpathQuery", ")", ";", "if", "(", "StringUtils", ".", "isNotEmpty", "(", "metaDataValue", ")", ")", "{", "item", ".", "setProperty", "(", "xpathQuery", ",", "metaDataValue", ")", ";", "}", "}", "return", "item", ";", "}" ]

[ "For", "every", "XPath", "query", "provided", "in", "{" ]

[ "LinesToCharsResult", "linesToChars", "(", "String", "text1", ",", "String", "text2", ")", "{", "List", "<", "String", ">", "lineArray", "=", "new", "ArrayList", "<>", "(", ")", ";", "Map", "<", "String", ",", "Integer", ">", "lineHash", "=", "new", "HashMap", "<>", "(", ")", ";", "// e.g. linearray[4] == \"Hello\\n\"", "// e.g. linehash.get(\"Hello\\n\") == 4", "// \"\\x00\" is a valid character, but various debuggers don't like it.", "// So we'll insert a junk entry to avoid generating a null character.", "lineArray", ".", "add", "(", "\"\"", ")", ";", "String", "chars1", "=", "linesToCharsMunge", "(", "text1", ",", "lineArray", ",", "lineHash", ")", ";", "String", "chars2", "=", "linesToCharsMunge", "(", "text2", ",", "lineArray", ",", "lineHash", ")", ";", "return", "new", "LinesToCharsResult", "(", "chars1", ",", "chars2", ",", "lineArray", ")", ";", "}" ]

[ "Split", "two", "texts", "into", "a", "list", "of", "strings", ".", "Reduce", "the", "texts", "to", "a", "string", "of", "hashes", "where", "each", "Unicode", "character", "represents", "one", "line", "." ]

[ "public", "void", "deleteFromSchema", "(", "Mutation", "mutation", ",", "String", "cfName", ",", "long", "timestamp", ")", "{", "ColumnFamily", "cf", "=", "mutation", ".", "addOrGet", "(", "SystemKeyspace", ".", "SCHEMA_TRIGGERS_CF", ")", ";", "int", "ldt", "=", "(", "int", ")", "(", "System", ".", "currentTimeMillis", "(", ")", "/", "1000", ")", ";", "Composite", "prefix", "=", "CFMetaData", ".", "SchemaTriggersCf", ".", "comparator", ".", "make", "(", "cfName", ",", "name", ")", ";", "cf", ".", "addAtom", "(", "new", "RangeTombstone", "(", "prefix", ",", "prefix", ".", "end", "(", ")", ",", "timestamp", ",", "ldt", ")", ")", ";", "}" ]

[ "Drop", "specified", "trigger", "from", "the", "schema", "using", "given", "mutation", "." ]

[ "public", "Integer", "addNode", "(", "final", "int", "termIndex", ",", "final", "String", "label", ")", "{", "if", "(", "label", "==", "null", ")", "{", "throw", "new", "InvalidArgument", "(", "\"label\"", ",", "label", ")", ";", "}", "// if we have already seen this term index, return", "Integer", "visitedIndex", "=", "termNodeIndex", ".", "get", "(", "termIndex", ")", ";", "if", "(", "visitedIndex", "!=", "null", ")", "{", "return", "visitedIndex", ";", "}", "// add this new proto node", "int", "pnIndex", "=", "protoNodes", ".", "size", "(", ")", ";", "protoNodes", ".", "add", "(", "label", ")", ";", "// bi-directionally map term index to node index", "termNodeIndex", ".", "put", "(", "termIndex", ",", "pnIndex", ")", ";", "nodeTermIndex", ".", "put", "(", "pnIndex", ",", "termIndex", ")", ";", "getEquivalences", "(", ")", ".", "put", "(", "pnIndex", ",", "getEquivalences", "(", ")", ".", "size", "(", ")", ")", ";", "return", "pnIndex", ";", "}" ]

[ "Adds", "a", "proto", "node", "{", "@link", "String", "label", "}", "for", "a", "specific", "{", "@link", "Integer", "term", "index", "}", ".", "If", "the", "{", "@link", "Integer", "term", "index", "}", "has", "already", "been", "added", "then", "its", "{", "@link", "Integer", "proto", "node", "index", "}", "will", "be", "returned", ".", "<p", ">", "This", "operation", "maintains", "the", "{", "@link", "Map", "map", "}", "of", "term", "index", "to", "node", "index", ".", "<", "/", "p", ">" ]

[ "public", "CMAWebhook", "fetchOne", "(", "String", "spaceId", ",", "String", "webhookId", ")", "{", "assertNotNull", "(", "spaceId", ",", "\"spaceId\"", ")", ";", "assertNotNull", "(", "webhookId", ",", "\"webhookId\"", ")", ";", "return", "service", ".", "fetchOne", "(", "spaceId", ",", "webhookId", ")", ".", "blockingFirst", "(", ")", ";", "}" ]

[ "Retrieve", "exactly", "one", "webhook", "whose", "id", "you", "know", ".", "<p", ">", "This", "method", "will", "override", "the", "configuration", "specified", "through", "{", "@link", "CMAClient", ".", "Builder#setSpaceId", "(", "String", ")", "}", "and", "will", "ignore", "{", "@link", "CMAClient", ".", "Builder#setEnvironmentId", "(", "String", ")", "}", "." ]

[ "public", "void", "finishMapJson", "(", "final", "JsonConvert", "convert", ",", "final", "Object", "...", "objs", ")", "{", "this", ".", "contentType", "=", "this", ".", "jsonContentType", ";", "if", "(", "this", ".", "recycleListener", "!=", "null", ")", "this", ".", "output", "=", "objs", ";", "finish", "(", "convert", ".", "convertMapTo", "(", "getBodyBufferSupplier", "(", ")", ",", "objs", ")", ")", ";", "}" ]

[ "将对象数组用Map的形式以JSON格式输出", "<br", ">", "例如", ":", "finishMap", "(", "a", "2", "b", "3", ")", "输出结果为", "{", "a", ":", "2", "b", ":", "3", "}" ]

[ "public", "static", "char", "forDigit", "(", "int", "digit", ",", "int", "radix", ")", "{", "if", "(", "digit", ">=", "0", "&&", "digit", "<", "radix", "&&", "radix", ">=", "Character", ".", "MIN_RADIX", "&&", "radix", "<=", "MAX_RADIX", ")", "{", "return", "digits", "[", "digit", "]", ";", "}", "return", "'", "'", ";", "}" ]

[ "Determines", "the", "character", "representation", "for", "a", "specific", "digit", "in", "the", "specified", "radix", "." ]

[ "public", "void", "fixupVariables", "(", "java", ".", "util", ".", "Vector", "vars", ",", "int", "globalsSize", ")", "{", "m_fixUpWasCalled", "=", "true", ";", "int", "sz", "=", "vars", ".", "size", "(", ")", ";", "for", "(", "int", "i", "=", "vars", ".", "size", "(", ")", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "QName", "qn", "=", "(", "QName", ")", "vars", ".", "elementAt", "(", "i", ")", ";", "// System.out.println(\"qn: \"+qn);", "if", "(", "qn", ".", "equals", "(", "m_qname", ")", ")", "{", "if", "(", "i", "<", "globalsSize", ")", "{", "m_isGlobal", "=", "true", ";", "m_index", "=", "i", ";", "}", "else", "{", "m_index", "=", "i", "-", "globalsSize", ";", "}", "return", ";", "}", "}", "java", ".", "lang", ".", "String", "msg", "=", "XSLMessages", ".", "createXPATHMessage", "(", "XPATHErrorResources", ".", "ER_COULD_NOT_FIND_VAR", ",", "new", "Object", "[", "]", "{", "m_qname", ".", "toString", "(", ")", "}", ")", ";", "TransformerException", "te", "=", "new", "TransformerException", "(", "msg", ",", "this", ")", ";", "throw", "new", "org", ".", "apache", ".", "xml", ".", "utils", ".", "WrappedRuntimeException", "(", "te", ")", ";", "}" ]

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

[ "private", "void", "validateProtocol", "(", "StatusLine", "statusLine", ",", "Map", "<", "String", ",", "List", "<", "String", ">", ">", "headers", ")", "throws", "WebSocketException", "{", "// Get the values of Sec-WebSocket-Protocol.", "List", "<", "String", ">", "values", "=", "headers", ".", "get", "(", "\"Sec-WebSocket-Protocol\"", ")", ";", "if", "(", "values", "==", "null", ")", "{", "// Nothing to check.", "return", ";", "}", "// Protocol", "String", "protocol", "=", "values", ".", "get", "(", "0", ")", ";", "if", "(", "protocol", "==", "null", "||", "protocol", ".", "length", "(", ")", "==", "0", ")", "{", "// Ignore.", "return", ";", "}", "// If the protocol is not contained in the original request", "// from this client.", "if", "(", "mWebSocket", ".", "getHandshakeBuilder", "(", ")", ".", "containsProtocol", "(", "protocol", ")", "==", "false", ")", "{", "// The protocol contained in the Sec-WebSocket-Protocol header is not supported.", "throw", "new", "OpeningHandshakeException", "(", "WebSocketError", ".", "UNSUPPORTED_PROTOCOL", ",", "\"The protocol contained in the Sec-WebSocket-Protocol header is not supported: \"", "+", "protocol", ",", "statusLine", ",", "headers", ")", ";", "}", "// Agreed protocol.", "mWebSocket", ".", "setAgreedProtocol", "(", "protocol", ")", ";", "}" ]

[ "Validate", "the", "value", "of", "{", "@code", "Sec", "-", "WebSocket", "-", "Protocol", "}", "header", "." ]

[ "public", "static", "void", "leetConvert", "(", "LeetLevel", "level", ",", "SecureCharArray", "message", ")", "throws", "Exception", "{", "// pre-allocate an array that is 4 times the size of the message. I don't", "// see anything in the leet-table that is larger than 3 characters, but I'm", "// using 4-characters to calcualte the size just in case. This is to avoid", "// a bunch of array resizes.", "SecureCharArray", "ret", "=", "new", "SecureCharArray", "(", "message", ".", "size", "(", ")", "*", "4", ")", ";", "char", "[", "]", "messageBytes", "=", "message", ".", "getData", "(", ")", ";", "// Reference to message's data", "char", "[", "]", "retBytes", "=", "ret", ".", "getData", "(", ")", ";", "// Reference to ret's data", "int", "currentRetByte", "=", "0", ";", "// Index of current ret byte", "if", "(", "level", ".", "compareTo", "(", "LeetLevel", ".", "LEVEL1", ")", ">=", "0", "&&", "level", ".", "compareTo", "(", "LeetLevel", ".", "LEVEL9", ")", "<=", "0", ")", "{", "for", "(", "char", "messageByte", ":", "messageBytes", ")", "{", "char", "b", "=", "Character", ".", "toLowerCase", "(", "messageByte", ")", ";", "if", "(", "b", ">=", "'", "'", "&&", "b", "<=", "'", "'", ")", "{", "for", "(", "int", "j", "=", "0", ";", "j", "<", "LEVELS", "[", "level", ".", "getLevel", "(", ")", "-", "1", "]", "[", "b", "-", "'", "'", "]", ".", "length", "(", ")", ";", "j", "++", ")", "retBytes", "[", "currentRetByte", "++", "]", "=", "LEVELS", "[", "level", ".", "getLevel", "(", ")", "-", "1", "]", "[", "-", "'", "'", "]", ".", "charAt", "(", "j", ")", ";", "}", "else", "{", "retBytes", "[", "currentRetByte", "++", "]", "=", "b", ";", "}", "}", "}", "// Resize the array to the length that we actually filled it, then replace", "// the original message and erase the buffer we built up.", "ret", ".", "resize", "(", "currentRetByte", ",", "true", ")", ";", "message", ".", "replace", "(", "ret", ")", ";", "ret", ".", "erase", "(", ")", ";", "}" ]

[ "Converts", "a", "SecureCharArray", "into", "a", "new", "SecureCharArray", "with", "any", "applicable", "characters", "converted", "to", "leet", "-", "speak", "." ]

[ "private", "int", "rangeCheck", "(", "int", "value", ",", "int", "begin", ",", "int", "end", ")", "{", "if", "(", "value", ">=", "begin", "&&", "value", "<=", "end", ")", "{", "// (begin,end]", "return", "value", ";", "}", "throw", "new", "IllegalArgumentException", "(", "\"Value [\"", "+", "value", "+", "\"] not in range [\"", "+", "begin", "+", "\",\"", "+", "end", "+", "\"]\"", ")", ";", "}" ]

[ "/", "*", "Convenience", "function", "to", "check", "integer", "boundaries", ".", "Checks", "if", "a", "value", "x", "is", "in", "the", "range", "[", "begin", "end", "]", ".", "Returns", "x", "if", "it", "is", "in", "range", "throws", "an", "exception", "otherwise", "." ]

[ "public", "void", "setValueAtIn", "(", "Object", "value", ",", "int", "index", ",", "List", "aList", ")", "{", "Object", "cleanValue", "=", "cleanupValue", "(", "value", ")", ";", "while", "(", "aList", ".", "size", "(", ")", "<=", "index", ")", "{", "aList", ".", "add", "(", "null", ")", ";", "}", "aList", ".", "set", "(", "index", ",", "cleanValue", ")", ";", "}" ]

[ "Sets", "value", "of", "element", "at", "index", "(", "0", "-", "based", ")", ".", "If", "the", "current", "list", "has", "less", "elements", "it", "is", "extended", "to", "have", "exactly", "index", "elements", "." ]

[ "protected", "void", "recycleChildren", "(", "RecyclerView", ".", "Recycler", "recycler", ",", "int", "startIndex", ",", "int", "endIndex", ")", "{", "if", "(", "startIndex", "==", "endIndex", ")", "{", "return", ";", "}", "if", "(", "DEBUG", ")", "{", "Log", ".", "d", "(", "TAG", ",", "\"Recycling \"", "+", "Math", ".", "abs", "(", "startIndex", "-", "endIndex", ")", "+", "\" items\"", ")", ";", "}", "if", "(", "endIndex", ">", "startIndex", ")", "{", "for", "(", "int", "i", "=", "endIndex", "-", "1", ";", "i", ">=", "startIndex", ";", "i", "--", ")", "{", "removeAndRecycleViewAt", "(", "i", ",", "recycler", ")", ";", "}", "}", "else", "{", "for", "(", "int", "i", "=", "startIndex", ";", "i", ">", "endIndex", ";", "i", "--", ")", "{", "removeAndRecycleViewAt", "(", "i", ",", "recycler", ")", ";", "}", "}", "}" ]

[ "Recycles", "children", "between", "given", "indices", "." ]

[ "@", "Override", "public", "void", "doRender", "(", "final", "WComponent", "component", ",", "final", "WebXmlRenderContext", "renderContext", ")", "{", "WEditableImage", "editableImage", "=", "(", "WEditableImage", ")", "component", ";", "XmlStringBuilder", "xml", "=", "renderContext", ".", "getWriter", "(", ")", ";", "// No image set", "if", "(", "editableImage", ".", "getImage", "(", ")", "==", "null", "&&", "editableImage", ".", "getImageUrl", "(", ")", "==", "null", ")", "{", "return", ";", "}", "WImageRenderer", ".", "renderTagOpen", "(", "editableImage", ",", "xml", ")", ";", "WComponent", "uploader", "=", "editableImage", ".", "getEditUploader", "(", ")", ";", "if", "(", "uploader", "!=", "null", ")", "{", "xml", ".", "appendAttribute", "(", "\"data-wc-editor\"", ",", "uploader", ".", "getId", "(", ")", ")", ";", "}", "xml", ".", "appendEnd", "(", ")", ";", "}" ]

[ "Paints", "the", "given", "{", "@link", "WEditableImage", "}", "." ]

[ "public", "byte", "[", "]", "toBytes", "(", "final", "DefinedRuntimes", "definedRuntimes", ")", "{", "final", "DatumWriter", "<", "DefinedRuntimes", ">", "configurationWriter", "=", "new", "SpecificDatumWriter", "<>", "(", "DefinedRuntimes", ".", "class", ")", ";", "try", "(", "final", "ByteArrayOutputStream", "out", "=", "new", "ByteArrayOutputStream", "(", ")", ")", "{", "final", "BinaryEncoder", "binaryEncoder", "=", "EncoderFactory", ".", "get", "(", ")", ".", "binaryEncoder", "(", "out", ",", "null", ")", ";", "configurationWriter", ".", "write", "(", "definedRuntimes", ",", "binaryEncoder", ")", ";", "binaryEncoder", ".", "flush", "(", ")", ";", "out", ".", "flush", "(", ")", ";", "return", "out", ".", "toByteArray", "(", ")", ";", "}", "catch", "(", "final", "IOException", "e", ")", "{", "throw", "new", "RuntimeException", "(", "\"Unable to serialize DefinedRuntimes\"", ",", "e", ")", ";", "}", "}" ]

[ "Serializes", "DefinedRuntimes", "." ]

[ "public", "static", "long", "count_filtered", "(", "nitro_service", "service", ",", "lbmonbindings", "obj", ",", "String", "filter", ")", "throws", "Exception", "{", "options", "option", "=", "new", "options", "(", ")", ";", "option", ".", "set_count", "(", "true", ")", ";", "option", ".", "set_filter", "(", "filter", ")", ";", "option", ".", "set_args", "(", "nitro_util", ".", "object_to_string_withoutquotes", "(", "obj", ")", ")", ";", "lbmonbindings", "[", "]", "response", "=", "(", "lbmonbindings", "[", "]", ")", "obj", ".", "getfiltered", "(", "service", ",", "option", ")", ";", "if", "(", "response", "!=", "null", ")", "{", "return", "response", "[", "0", "]", ".", "__count", ";", "}", "return", "0", ";", "}" ]

[ "Use", "this", "API", "to", "count", "filtered", "the", "set", "of", "lbmonbindings", "resources", ".", "filter", "string", "should", "be", "in", "JSON", "format", ".", "eg", ":", "port", ":", "80", "servicetype", ":", "HTTP", "." ]

[ "public", "void", "unregisterWorkflowDef", "(", "String", "name", ",", "Integer", "version", ")", "{", "Preconditions", ".", "checkArgument", "(", "StringUtils", ".", "isNotBlank", "(", "name", ")", ",", "\"Workflow name cannot be blank\"", ")", ";", "Preconditions", ".", "checkNotNull", "(", "version", ",", "\"Version cannot be null\"", ")", ";", "delete", "(", "\"metadata/workflow/{name}/{version}\"", ",", "name", ",", "version", ")", ";", "}" ]

[ "Removes", "the", "workflow", "definition", "of", "a", "workflow", "from", "the", "conductor", "server", ".", "It", "does", "not", "remove", "associated", "workflows", ".", "Use", "with", "caution", "." ]

[ "private", "void", "readPackageListFromFile", "(", "String", "path", ",", "DocFile", "pkgListPath", ")", "throws", "Fault", "{", "DocFile", "file", "=", "pkgListPath", ".", "resolve", "(", "DocPaths", ".", "PACKAGE_LIST", ")", ";", "if", "(", "!", "(", "file", ".", "isAbsolute", "(", ")", "||", "linkoffline", ")", ")", "{", "file", "=", "file", ".", "resolveAgainst", "(", "DocumentationTool", ".", "Location", ".", "DOCUMENTATION_OUTPUT", ")", ";", "}", "try", "{", "if", "(", "file", ".", "exists", "(", ")", "&&", "file", ".", "canRead", "(", ")", ")", "{", "boolean", "pathIsRelative", "=", "!", "DocFile", ".", "createFileForInput", "(", "configuration", ",", "path", ")", ".", "isAbsolute", "(", ")", "&&", "!", "isUrl", "(", "path", ")", ";", "readPackageList", "(", "file", ".", "openInputStream", "(", ")", ",", "path", ",", "pathIsRelative", ")", ";", "}", "else", "{", "throw", "new", "Fault", "(", "configuration", ".", "getText", "(", "\"doclet.File_error\"", ",", "file", ".", "getPath", "(", ")", ")", ",", "null", ")", ";", "}", "}", "catch", "(", "IOException", "exc", ")", "{", "throw", "new", "Fault", "(", "configuration", ".", "getText", "(", "\"doclet.File_error\"", ",", "file", ".", "getPath", "(", ")", ")", ",", "exc", ")", ";", "}", "}" ]

[ "Read", "the", "package", "-", "list", "file", "which", "is", "available", "locally", "." ]

[ "public", "static", "void", "unescapeUriFragmentId", "(", "final", "Reader", "reader", ",", "final", "Writer", "writer", ")", "throws", "IOException", "{", "unescapeUriFragmentId", "(", "reader", ",", "writer", ",", "DEFAULT_ENCODING", ")", ";", "}" ]

[ "<p", ">", "Perform", "am", "URI", "fragment", "identifier", "<strong", ">", "unescape<", "/", "strong", ">", "operation", "on", "a", "<tt", ">", "Reader<", "/", "tt", ">", "input", "using", "<tt", ">", "UTF", "-", "8<", "/", "tt", ">", "as", "encoding", "writing", "results", "to", "a", "<tt", ">", "Writer<", "/", "tt", ">", ".", "<", "/", "p", ">", "<p", ">", "This", "method", "will", "unescape", "every", "percent", "-", "encoded", "(", "<tt", ">", "%HH<", "/", "tt", ">", ")", "sequences", "present", "in", "input", "even", "for", "those", "characters", "that", "do", "not", "need", "to", "be", "percent", "-", "encoded", "in", "this", "context", "(", "unreserved", "characters", "can", "be", "percent", "-", "encoded", "even", "if", "/", "when", "this", "is", "not", "required", "though", "it", "is", "not", "generally", "considered", "a", "good", "practice", ")", ".", "<", "/", "p", ">", "<p", ">", "This", "method", "will", "use", "<tt", ">", "UTF", "-", "8<", "/", "tt", ">", "in", "order", "to", "determine", "the", "characters", "specified", "in", "the", "percent", "-", "encoded", "byte", "sequences", ".", "<", "/", "p", ">", "<p", ">", "This", "method", "is", "<strong", ">", "thread", "-", "safe<", "/", "strong", ">", ".", "<", "/", "p", ">" ]

[ "public", "GetVolumeResponse", "getVolume", "(", "GetVolumeRequest", "request", ")", "{", "checkNotNull", "(", "request", ",", "\"request should not be null.\"", ")", ";", "checkStringNotEmpty", "(", "request", ".", "getVolumeId", "(", ")", ",", "\"request volumeId should not be empty.\"", ")", ";", "InternalRequest", "internalRequest", "=", "this", ".", "createRequest", "(", "request", ",", "HttpMethodName", ".", "GET", ",", "VOLUME_PREFIX", ",", "request", ".", "getVolumeId", "(", ")", ")", ";", "return", "invokeHttpClient", "(", "internalRequest", ",", "GetVolumeResponse", ".", "class", ")", ";", "}" ]

[ "Get", "the", "detail", "information", "of", "specified", "volume", "." ]

[ "public", "static", "DataSource", "createDataSource", "(", "String", "driverClassName", ",", "String", "url", ",", "String", "userName", ",", "String", "password", ",", "int", "initialSize", ",", "int", "maxActive", ")", "throws", "SQLException", "{", "assertNotNull", "(", "driverClassName", ")", ";", "assertNotNull", "(", "url", ")", ";", "assertNotNull", "(", "userName", ")", ";", "assertNotNull", "(", "password", ")", ";", "BasicDataSource", "ds", "=", "new", "BasicDataSource", "(", ")", ";", "ds", ".", "setDriverClassName", "(", "driverClassName", ")", ";", "ds", ".", "setUrl", "(", "url", ")", ";", "ds", ".", "setUsername", "(", "userName", ")", ";", "ds", ".", "setPassword", "(", "password", ")", ";", "ds", ".", "setMaxActive", "(", "maxActive", ")", ";", "ds", ".", "setInitialSize", "(", "initialSize", ")", ";", "return", "ds", ";", "}" ]

[ "Returns", "new", "Pooled", "{", "@link", "DataSource", "}", "implementation", "<p", "/", ">", "In", "case", "this", "function", "won", "t", "work", "-", "use", "{", "@link", "#createDataSource", "(", "java", ".", "util", ".", "Properties", ")", "}" ]

[ "@", "Override", "public", "Configuration", "getDefault", "(", ")", "{", "return", "new", "Configuration", "(", ")", "{", "@", "Override", "public", "HttpClient", "httpClient", "(", ")", "{", "try", "{", "SchemeRegistry", "schemeRegistry", "=", "new", "SchemeRegistry", "(", ")", ";", "schemeRegistry", ".", "register", "(", "new", "Scheme", "(", "\"http\"", ",", "80", ",", "PlainSocketFactory", ".", "getSocketFactory", "(", ")", ")", ")", ";", "schemeRegistry", ".", "register", "(", "new", "Scheme", "(", "\"https\"", ",", "443", ",", "SSLSocketFactory", ".", "getSocketFactory", "(", ")", ")", ")", ";", "PoolingClientConnectionManager", "pccm", "=", "new", "PoolingClientConnectionManager", "(", "schemeRegistry", ")", ";", "pccm", ".", "setMaxTotal", "(", "200", ")", ";", "pccm", ".", "setDefaultMaxPerRoute", "(", "20", ")", ";", "return", "new", "DefaultHttpClient", "(", "pccm", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "ConfigurationFailedException", "(", "e", ")", ";", "}", "}", "}", ";", "}" ]

[ "<p", ">", "The", "<i", ">", "out", "-", "of", "-", "the", "-", "box<", "/", "i", ">", "configuration", "for", "an", "instance", "of", "{", "@link", "HttpClient", "}", "which", "will", "be", "used", "for", "executing", "all", "endpoint", "requests", ".", "Below", "is", "a", "detailed", "description", "of", "all", "configured", "properties", ".", "<", "/", "p", ">", "<br", ">", "<ul", ">", "<li", ">", "<p", ">", "<b", ">", "HttpClient<", "/", "b", ">", "<", "/", "p", ">", "<br", ">", "<p", ">", "It", "registers", "two", "{", "@link", "Scheme", "}", "s", ":", "<", "/", "p", ">", "<br", ">", "<ol", ">", "<li", ">", "<b", ">", "HTTP<", "/", "b", ">", "on", "port", "<b", ">", "80<", "/", "b", ">", "using", "sockets", "from", "{", "@link", "PlainSocketFactory#getSocketFactory", "}", "<", "/", "li", ">", "<li", ">", "<b", ">", "HTTPS<", "/", "b", ">", "on", "port", "<b", ">", "443<", "/", "b", ">", "using", "sockets", "from", "{", "@link", "SSLSocketFactory#getSocketFactory", "}", "<", "/", "li", ">", "<", "/", "ol", ">" ]

[ "static", "double", "expint", "(", "int", "p", ",", "final", "double", "result", "[", "]", ")", "{", "//double x = M_E;", "final", "double", "xs", "[", "]", "=", "new", "double", "[", "2", "]", ";", "final", "double", "as", "[", "]", "=", "new", "double", "[", "2", "]", ";", "final", "double", "ys", "[", "]", "=", "new", "double", "[", "2", "]", ";", "//split(x, xs);", "//xs[1] = (double)(2.7182818284590452353602874713526625L - xs[0]);", "//xs[0] = 2.71827697753906250000;", "//xs[1] = 4.85091998273542816811e-06;", "//xs[0] = Double.longBitsToDouble(0x4005bf0800000000L);", "//xs[1] = Double.longBitsToDouble(0x3ed458a2bb4a9b00L);", "/* E */", "xs", "[", "0", "]", "=", "2.718281828459045", ";", "xs", "[", "1", "]", "=", "1.4456468917292502E-16", ";", "split", "(", "1.0", ",", "ys", ")", ";", "while", "(", "p", ">", "0", ")", "{", "if", "(", "(", "p", "&", "1", ")", "!=", "0", ")", "{", "quadMult", "(", "ys", ",", "xs", ",", "as", ")", ";", "ys", "[", "0", "]", "=", "as", "[", "0", "]", ";", "ys", "[", "1", "]", "=", "as", "[", "1", "]", ";", "}", "quadMult", "(", "xs", ",", "xs", ",", "as", ")", ";", "xs", "[", "0", "]", "=", "as", "[", "0", "]", ";", "xs", "[", "1", "]", "=", "as", "[", "1", "]", ";", "p", ">>=", "1", ";", "}", "if", "(", "result", "!=", "null", ")", "{", "result", "[", "0", "]", "=", "ys", "[", "0", "]", ";", "result", "[", "1", "]", "=", "ys", "[", "1", "]", ";", "resplit", "(", "result", ")", ";", "}", "return", "ys", "[", "0", "]", "+", "ys", "[", "1", "]", ";", "}" ]

[ "Compute", "exp", "(", "p", ")", "for", "a", "integer", "p", "in", "extended", "precision", "." ]

[ "public", "static", "void", "traceBeanState", "(", "int", "oldState", ",", "String", "oldString", ",", "int", "newState", ",", "String", "newString", ")", "// d167264", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "StringBuffer", "sbuf", "=", "new", "StringBuffer", "(", ")", ";", "sbuf", ".", "append", "(", "BeanLifeCycle_State_Type_Str", ")", ".", "append", "(", "DataDelimiter", ")", ".", "append", "(", "BeanLifeCycle_State_Type", ")", ".", "append", "(", "DataDelimiter", ")", ".", "append", "(", "oldState", ")", ".", "append", "(", "DataDelimiter", ")", "// d167264", ".", "append", "(", "oldString", ")", ".", "append", "(", "DataDelimiter", ")", "// d167264", ".", "append", "(", "newState", ")", ".", "append", "(", "DataDelimiter", ")", "// d167264", ".", "append", "(", "newString", ")", ".", "append", "(", "DataDelimiter", ")", "// d167264", ";", "Tr", ".", "debug", "(", "tc", ",", "sbuf", ".", "toString", "(", ")", ")", ";", "}", "}" ]

[ "This", "is", "called", "by", "the", "EJB", "container", "server", "code", "to", "write", "a", "ejb", "bean", "state", "record", "to", "the", "trace", "log", "if", "enabled", "." ]

[ "final", "void", "alterLocalizationPoint", "(", "BaseDestination", "dest", ",", "LWMConfig", "lp", ")", "{", "String", "thisMethodName", "=", "\"alterLocalizationPoint\"", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "{", "SibTr", ".", "entry", "(", "tc", ",", "thisMethodName", ",", "lp", ")", ";", "}", "try", "{", "_localizer", ".", "alterLocalizationPoint", "(", "dest", ",", "lp", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "SibTr", ".", "exception", "(", "tc", ",", "e", ")", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "{", "SibTr", ".", "exit", "(", "tc", ",", "thisMethodName", ")", ";", "}", "}" ]

[ "Pass", "the", "request", "to", "alter", "a", "localization", "point", "onto", "the", "localizer", "object", "." ]

[ "public", "Matrix3d", "rotateTowards", "(", "double", "dirX", ",", "double", "dirY", ",", "double", "dirZ", ",", "double", "upX", ",", "double", "upY", ",", "double", "upZ", ")", "{", "return", "rotateTowards", "(", "dirX", ",", "dirY", ",", "dirZ", ",", "upX", ",", "upY", ",", "upZ", ",", "this", ")", ";", "}" ]

[ "Apply", "a", "model", "transformation", "to", "this", "matrix", "for", "a", "right", "-", "handed", "coordinate", "system", "that", "aligns", "the", "local", "<code", ">", "+", "Z<", "/", "code", ">", "axis", "with", "<code", ">", "direction<", "/", "code", ">", ".", "<p", ">", "If", "<code", ">", "M<", "/", "code", ">", "is", "<code", ">", "this<", "/", "code", ">", "matrix", "and", "<code", ">", "L<", "/", "code", ">", "the", "lookat", "matrix", "then", "the", "new", "matrix", "will", "be", "<code", ">", "M", "*", "L<", "/", "code", ">", ".", "So", "when", "transforming", "a", "vector", "<code", ">", "v<", "/", "code", ">", "with", "the", "new", "matrix", "by", "using", "<code", ">", "M", "*", "L", "*", "v<", "/", "code", ">", "the", "lookat", "transformation", "will", "be", "applied", "first!", "<p", ">", "In", "order", "to", "set", "the", "matrix", "to", "a", "rotation", "transformation", "without", "post", "-", "multiplying", "it", "use", "{", "@link", "#rotationTowards", "(", "double", "double", "double", "double", "double", "double", ")", "rotationTowards", "()", "}", ".", "<p", ">", "This", "method", "is", "equivalent", "to", "calling", ":", "<code", ">", "mul", "(", "new", "Matrix3d", "()", ".", "lookAlong", "(", "-", "dirX", "-", "dirY", "-", "dirZ", "upX", "upY", "upZ", ")", ".", "invert", "()", ")", "<", "/", "code", ">" ]

[ "public", "void", "sendAll", "(", "String", "apiKey", ",", "String", "queue", ",", "Collection", "<", "?", ">", "messages", ")", "{", "checkNotNull", "(", "queue", ",", "\"queue\"", ")", ";", "checkNotNull", "(", "messages", ",", "\"messages\"", ")", ";", "if", "(", "messages", ".", "isEmpty", "(", ")", ")", "{", "return", ";", "}", "try", "{", "URI", "uri", "=", "_queueService", ".", "clone", "(", ")", ".", "segment", "(", "queue", ",", "\"sendbatch\"", ")", ".", "build", "(", ")", ";", "_client", ".", "resource", "(", "uri", ")", ".", "type", "(", "MediaType", ".", "APPLICATION_JSON_TYPE", ")", ".", "header", "(", "ApiKeyRequest", ".", "AUTHENTICATION_HEADER", ",", "apiKey", ")", ".", "post", "(", "messages", ")", ";", "}", "catch", "(", "EmoClientException", "e", ")", "{", "throw", "convertException", "(", "e", ")", ";", "}", "}" ]

[ "Any", "server", "can", "handle", "sending", "messages", "no", "need", "for" ]

[ "int", "getMethodIndex", "(", "ExecutableElement", "method", ")", "{", "TypeElement", "declaringClass", "=", "(", "TypeElement", ")", "method", ".", "getEnclosingElement", "(", ")", ";", "String", "fullyQualifiedname", "=", "declaringClass", ".", "getQualifiedName", "(", ")", ".", "toString", "(", ")", ";", "return", "getRefIndex", "(", "Methodref", ".", "class", ",", "fullyQualifiedname", ",", "method", ".", "getSimpleName", "(", ")", ".", "toString", "(", ")", ",", "Descriptor", ".", "getDesriptor", "(", "method", ")", ")", ";", "}" ]

[ "Returns", "the", "constant", "map", "index", "to", "method" ]

[ "private", "void", "addCommandMember", "(", "String", "commandId", ",", "CommandGroup", "group", ")", "{", "Assert", ".", "notNull", "(", "commandId", ",", "\"commandId\"", ")", ";", "Assert", ".", "notNull", "(", "group", ",", "\"group\"", ")", ";", "if", "(", "logger", ".", "isDebugEnabled", "(", ")", ")", "{", "logger", ".", "debug", "(", "\"adding command group member with id [\"", "+", "commandId", "+", "\"] to group [\"", "+", "group", ".", "getId", "(", ")", "+", "\"]\"", ")", ";", "}", "AbstractCommand", "command", "=", "null", ";", "if", "(", "getCommandRegistry", "(", ")", "!=", "null", ")", "{", "command", "=", "(", "AbstractCommand", ")", "getCommandRegistry", "(", ")", ".", "getCommand", "(", "commandId", ")", ";", "if", "(", "command", "!=", "null", ")", "{", "group", ".", "addInternal", "(", "command", ")", ";", "}", "}", "if", "(", "command", "==", "null", ")", "{", "group", ".", "addLazyInternal", "(", "commandId", ")", ";", "}", "}" ]

[ "Adds", "the", "command", "object", "with", "the", "given", "id", "to", "the", "given", "command", "group", ".", "If", "a", "command", "registry", "has", "not", "yet", "been", "provided", "to", "this", "factory", "the", "command", "id", "will", "be", "passed", "as", "a", "lazy", "placeholder", "to", "the", "group", "instead", "." ]

[ "public", "static", "String", "encodeUrlSafe", "(", "String", "source", ",", "String", "charset", ")", "{", "return", "encodeUrlSafe", "(", "StrUtil", ".", "bytes", "(", "source", ",", "charset", ")", ",", "charset", ")", ";", "}" ]

[ "base64编码", "URL安全" ]

[ "public", "void", "getUsersAsync", "(", "UserSearchParams", "searchParams", ",", "AsyncCallback", "callback", ")", "throws", "ProvisioningApiException", "{", "getUsersAsync", "(", "searchParams", ".", "getLimit", "(", ")", ",", "searchParams", ".", "getOffset", "(", ")", ",", "searchParams", ".", "getOrder", "(", ")", ",", "searchParams", ".", "getSortBy", "(", ")", ",", "searchParams", ".", "getFilterName", "(", ")", ",", "searchParams", ".", "getFilterParameters", "(", ")", ",", "searchParams", ".", "getRoles", "(", ")", ",", "searchParams", ".", "getSkills", "(", ")", ",", "searchParams", ".", "getUserEnabled", "(", ")", ",", "searchParams", ".", "getUserValid", "(", ")", ",", "callback", ")", ";", "}" ]

[ "Get", "users", ".", "Get", "[", "CfgPerson", "]", "(", "https", ":", "//", "docs", ".", "genesys", ".", "com", "/", "Documentation", "/", "PSDK", "/", "latest", "/", "ConfigLayerRef", "/", "CfgPerson", ")", "objects", "based", "on", "the", "specified", "filters", "." ]

[ "public", "void", "addDwgObjectOffset", "(", "int", "handle", ",", "int", "offset", ")", "{", "DwgObjectOffset", "doo", "=", "new", "DwgObjectOffset", "(", "handle", ",", "offset", ")", ";", "dwgObjectOffsets", ".", "add", "(", "doo", ")", ";", "}" ]

[ "Add", "a", "DWG", "object", "offset", "to", "the", "dwgObjectOffsets", "vector" ]

[ "public", "static", "double", "distanceSegmentPoint", "(", "double", "startX", ",", "double", "startY", ",", "double", "endX", ",", "double", "endY", ",", "double", "pointX", ",", "double", "pointY", ")", "{", "Point", "nearest", "=", "nearestSegmentPoint", "(", "startX", ",", "startY", ",", "endX", ",", "endY", ",", "pointX", ",", "pointY", ")", ";", "return", "Math", ".", "hypot", "(", "nearest", ".", "x", "-", "pointX", ",", "nearest", ".", "y", "-", "pointY", ")", ";", "}" ]

[ "Returns", "the", "distance", "between", "the", "given", "segment", "and", "point", ".", "<p", ">", "libGDX", "(", "Apache", "2", ".", "0", ")" ]

[ "public", "void", "addRelationship", "(", "int", "linkType", ",", "Record", "recLeft", ",", "Record", "recRight", ",", "String", "fldLeft1", ",", "String", "fldRight1", ",", "String", "fldLeft2", ",", "String", "fldRight2", ",", "String", "fldLeft3", ",", "String", "fldRight3", ")", "{", "new", "TableLink", "(", "this", ",", "linkType", ",", "recLeft", ",", "recRight", ",", "fldLeft1", ",", "fldRight1", ",", "fldLeft2", ",", "fldRight2", ",", "fldLeft3", ",", "fldRight3", ")", ";", "}" ]

[ "Add", "this", "table", "link", "to", "this", "query", ".", "Creates", "a", "new", "tablelink", "and", "adds", "it", "to", "the", "link", "list", "." ]

[ "public", "PathBuilder", "cubicTo", "(", "Point2d", "cp1", ",", "Point2d", "cp2", ",", "Point2d", "ep", ")", "{", "add", "(", "new", "CubicTo", "(", "cp1", ",", "cp2", ",", "ep", ")", ")", ";", "return", "this", ";", "}" ]

[ "Make", "a", "cubic", "curve", "in", "the", "path", "with", "two", "control", "points", "." ]

[ "public", "ResultByTime", "withTotal", "(", "java", ".", "util", ".", "Map", "<", "String", ",", "MetricValue", ">", "total", ")", "{", "setTotal", "(", "total", ")", ";", "return", "this", ";", "}" ]

[ "<p", ">", "The", "total", "amount", "of", "cost", "or", "usage", "accrued", "during", "the", "time", "period", ".", "<", "/", "p", ">" ]

[ "public", "static", "<", "S1", ",", "I1", ",", "T1", ",", "SP", ",", "TP", ",", "S2", ",", "I2", ",", "T2", ">", "Mapping", "<", "S1", ",", "S2", ">", "copy", "(", "TSTraversalMethod", "method", ",", "UniversalTransitionSystem", "<", "S1", ",", "?", "super", "I1", ",", "T1", ",", "?", "extends", "SP", ",", "?", "extends", "TP", ">", "in", ",", "int", "limit", ",", "Collection", "<", "?", "extends", "I1", ">", "inputs", ",", "MutableAutomaton", "<", "S2", ",", "I2", ",", "T2", ",", "?", "super", "SP", ",", "?", "super", "TP", ">", "out", ",", "Function", "<", "?", "super", "I1", ",", "?", "extends", "I2", ">", "inputsMapping", ")", "{", "return", "copy", "(", "method", ",", "in", ",", "limit", ",", "inputs", ",", "out", ",", "inputsMapping", ",", "x", "->", "true", ",", "TransitionPredicates", ".", "alwaysTrue", "(", ")", ")", ";", "}" ]

[ "Copies", "a", "{", "@link", "UniversalAutomaton", "}", "with", "possibly", "heterogeneous", "input", "alphabets", "but", "compatible", "properties", ".", "States", "and", "transitions", "will", "not", "be", "filtered" ]

[ "public", "static", "void", "runReadLoop", "(", "InputStream", "stream", ",", "StreamConnection", "connection", ")", "throws", "Exception", "{", "ByteBuffer", "dbuf", "=", "ByteBuffer", ".", "allocateDirect", "(", "Math", ".", "min", "(", "Math", ".", "max", "(", "connection", ".", "getMaxMessageSize", "(", ")", ",", "BUFFER_SIZE_LOWER_BOUND", ")", ",", "BUFFER_SIZE_UPPER_BOUND", ")", ")", ";", "byte", "[", "]", "readBuff", "=", "new", "byte", "[", "dbuf", ".", "capacity", "(", ")", "]", ";", "while", "(", "true", ")", "{", "// TODO Kill the message duplication here", "checkState", "(", "dbuf", ".", "remaining", "(", ")", ">", "0", "&&", "dbuf", ".", "remaining", "(", ")", "<=", "readBuff", ".", "length", ")", ";", "int", "read", "=", "stream", ".", "read", "(", "readBuff", ",", "0", ",", "Math", ".", "max", "(", "1", ",", "Math", ".", "min", "(", "dbuf", ".", "remaining", "(", ")", ",", "stream", ".", "available", "(", ")", ")", ")", ")", ";", "if", "(", "read", "==", "-", "1", ")", "return", ";", "dbuf", ".", "put", "(", "readBuff", ",", "0", ",", "read", ")", ";", "// \"flip\" the buffer - setting the limit to the current position and setting position to 0", "dbuf", ".", "flip", "(", ")", ";", "// Use connection.receiveBytes's return value as a double-check that it stopped reading at the right", "// location", "int", "bytesConsumed", "=", "connection", ".", "receiveBytes", "(", "dbuf", ")", ";", "checkState", "(", "dbuf", ".", "position", "(", ")", "==", "bytesConsumed", ")", ";", "// Now drop the bytes which were read by compacting dbuf (resetting limit and keeping relative", "// position)", "dbuf", ".", "compact", "(", ")", ";", "}", "}" ]

[ "A", "blocking", "call", "that", "never", "returns", "except", "by", "throwing", "an", "exception", ".", "It", "reads", "bytes", "from", "the", "input", "stream", "and", "feeds", "them", "to", "the", "provided", "{" ]

[ "public", "TextRange", "newRange", "(", "int", "startOffset", ",", "int", "endOffset", ")", "{", "checkMetadata", "(", ")", ";", "return", "newRangeValidPointers", "(", "newPointer", "(", "startOffset", ")", ",", "newPointer", "(", "endOffset", ")", ",", "false", ")", ";", "}" ]

[ "Create", "Range", "from", "global", "offsets", ".", "Used", "for", "backward", "compatibility", "with", "older", "API", "." ]

[ "private", "static", "QueryInterval", "convertSimpleIntervalToQueryInterval", "(", "final", "Interval", "interval", ",", "final", "SAMSequenceDictionary", "sequenceDictionary", ")", "{", "if", "(", "interval", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"interval may not be null\"", ")", ";", "}", "if", "(", "sequenceDictionary", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"sequence dictionary may not be null\"", ")", ";", "}", "final", "int", "contigIndex", "=", "sequenceDictionary", ".", "getSequenceIndex", "(", "interval", ".", "getContig", "(", ")", ")", ";", "if", "(", "contigIndex", "==", "-", "1", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Contig \"", "+", "interval", ".", "getContig", "(", ")", "+", "\" not present in reads sequence \"", "+", "\"dictionary\"", ")", ";", "}", "return", "new", "QueryInterval", "(", "contigIndex", ",", "interval", ".", "getStart", "(", ")", ",", "interval", ".", "getEnd", "(", ")", ")", ";", "}" ]

[ "Converts", "an", "interval", "in", "SimpleInterval", "format", "into", "an", "htsjdk", "QueryInterval", "." ]

[ "public", "synchronized", "void", "requestPreviewFrame", "(", "Handler", "handler", ",", "int", "message", ")", "{", "OpenCamera", "theCamera", "=", "camera", ";", "if", "(", "theCamera", "!=", "null", "&&", "previewing", ")", "{", "previewCallback", ".", "setHandler", "(", "handler", ",", "message", ")", ";", "theCamera", ".", "getCamera", "(", ")", ".", "setOneShotPreviewCallback", "(", "previewCallback", ")", ";", "}", "}" ]

[ "A", "single", "preview", "frame", "will", "be", "returned", "to", "the", "handler", "supplied", ".", "The", "data", "will", "arrive", "as", "byte", "[]", "in", "the", "message", ".", "obj", "field", "with", "width", "and", "height", "encoded", "as", "message", ".", "arg1", "and", "message", ".", "arg2", "respectively", "." ]

[ "public", "JerseyModuleExtender", "setProperty", "(", "String", "name", ",", "Object", "value", ")", "{", "contributeProperties", "(", ")", ".", "addBinding", "(", "name", ")", ".", "toInstance", "(", "value", ")", ";", "return", "this", ";", "}" ]

[ "Sets", "Jersey", "container", "property", ".", "This", "allows", "setting", "ResourceConfig", "properties", "that", "can", "not", "be", "set", "via", "JAX", "RS", "features", "." ]

[ "public", "static", "boolean", "isSubclass", "(", "String", "superclass", ",", "String", "otherclass", ")", "{", "String", "key", ";", "key", "=", "superclass", "+", "\"-\"", "+", "otherclass", ";", "if", "(", "m_CheckSubClass", ".", "containsKey", "(", "key", ")", ")", "return", "m_CheckSubClass", ".", "get", "(", "key", ")", ";", "try", "{", "return", "isSubclass", "(", "Class", ".", "forName", "(", "superclass", ")", ",", "Class", ".", "forName", "(", "otherclass", ")", ")", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "return", "false", ";", "}", "}" ]

[ "Checks", "whether", "the", "otherclass", "is", "a", "subclass", "of", "the", "given", "superclass", "." ]

[ "public", "AgentChatHistory", "getAgentHistory", "(", "EntityBareJid", "jid", ",", "int", "maxSessions", ",", "Date", "startDate", ")", "throws", "XMPPException", ",", "NotConnectedException", ",", "InterruptedException", "{", "AgentChatHistory", "request", ";", "if", "(", "startDate", "!=", "null", ")", "{", "request", "=", "new", "AgentChatHistory", "(", "jid", ",", "maxSessions", ",", "startDate", ")", ";", "}", "else", "{", "request", "=", "new", "AgentChatHistory", "(", "jid", ",", "maxSessions", ")", ";", "}", "request", ".", "setType", "(", "IQ", ".", "Type", ".", "get", ")", ";", "request", ".", "setTo", "(", "workgroupJID", ")", ";", "AgentChatHistory", "response", "=", "connection", ".", "createStanzaCollectorAndSend", "(", "request", ")", ".", "nextResult", "(", ")", ";", "return", "response", ";", "}" ]

[ "Retrieves", "the", "AgentChatHistory", "associated", "with", "a", "particular", "agent", "jid", "." ]

[ "public", "static", "<", "T", "extends", "CharSequence", ">", "T", "validateUUID", "(", "T", "value", ",", "String", "errorMsg", ")", "throws", "ValidateException", "{", "if", "(", "false", "==", "isUUID", "(", "value", ")", ")", "{", "throw", "new", "ValidateException", "(", "errorMsg", ")", ";", "}", "return", "value", ";", "}" ]

[ "验证是否为UUID<br", ">", "包括带横线标准格式和不带横线的简单模式" ]

[ "@", "DELETE", "@", "Produces", "(", "MediaType", ".", "APPLICATION_JSON", ")", "@", "Path", "(", "\"/{alertId}/notifications/{notificationId}\"", ")", "@", "Description", "(", "\"Deletes a notification having the given ID if it is associated with the given alert ID. Associated triggers are not deleted from the alert.\"", ")", "public", "Response", "deleteNotificationsById", "(", "@", "Context", "HttpServletRequest", "req", ",", "@", "PathParam", "(", "\"alertId\"", ")", "BigInteger", "alertId", ",", "@", "PathParam", "(", "\"notificationId\"", ")", "BigInteger", "notificationId", ")", "{", "if", "(", "alertId", "==", "null", "||", "alertId", ".", "compareTo", "(", "BigInteger", ".", "ZERO", ")", "<", "1", ")", "{", "throw", "new", "WebApplicationException", "(", "\"Alert Id cannot be null and must be a positive non-zero number.\"", ",", "Status", ".", "BAD_REQUEST", ")", ";", "}", "if", "(", "notificationId", "==", "null", "||", "notificationId", ".", "compareTo", "(", "BigInteger", ".", "ZERO", ")", "<", "1", ")", "{", "throw", "new", "WebApplicationException", "(", "\"Notification Id cannot be null and must be a positive non-zero number.\"", ",", "Status", ".", "BAD_REQUEST", ")", ";", "}", "Alert", "alert", "=", "alertService", ".", "findAlertByPrimaryKey", "(", "alertId", ")", ";", "if", "(", "alert", "==", "null", ")", "{", "throw", "new", "WebApplicationException", "(", "Response", ".", "Status", ".", "NOT_FOUND", ".", "getReasonPhrase", "(", ")", ",", "Response", ".", "Status", ".", "NOT_FOUND", ")", ";", "}", "validateResourceAuthorization", "(", "req", ",", "alert", ".", "getOwner", "(", ")", ",", "getRemoteUser", "(", "req", ")", ")", ";", "List", "<", "Notification", ">", "listNotification", "=", "new", "ArrayList", "<", "Notification", ">", "(", "alert", ".", "getNotifications", "(", ")", ")", ";", "Iterator", "<", "Notification", ">", "it", "=", "listNotification", ".", "iterator", "(", ")", ";", "while", "(", "it", ".", "hasNext", "(", ")", ")", "{", "Notification", "notification", "=", "it", ".", "next", "(", ")", ";", "if", "(", "notification", ".", "getId", "(", ")", ".", "equals", "(", "notificationId", ")", ")", "{", "it", ".", "remove", "(", ")", ";", "alert", ".", "setNotifications", "(", "listNotification", ")", ";", "alert", ".", "setModifiedBy", "(", "getRemoteUser", "(", "req", ")", ")", ";", "alertService", ".", "updateAlert", "(", "alert", ")", ";", "return", "Response", ".", "status", "(", "Status", ".", "OK", ")", ".", "build", "(", ")", ";", "}", "}", "throw", "new", "WebApplicationException", "(", "Response", ".", "Status", ".", "NOT_FOUND", ".", "getReasonPhrase", "(", ")", ",", "Response", ".", "Status", ".", "NOT_FOUND", ")", ";", "}" ]

[ "Deletes", "the", "notification", "." ]

[ "public", "void", "put", "(", "K", "[", "]", "key", ",", "V", "value", ")", "{", "Node", "child", "=", "root", ".", "get", "(", "key", "[", "0", "]", ")", ";", "if", "(", "child", "==", "null", ")", "{", "child", "=", "new", "Node", "(", "key", "[", "0", "]", ")", ";", "root", ".", "put", "(", "key", "[", "0", "]", ",", "child", ")", ";", "}", "child", ".", "addChild", "(", "key", ",", "value", ",", "1", ")", ";", "}" ]

[ "Add", "a", "key", "with", "associated", "value", "to", "the", "trie", "." ]

[ "private", "LinearEquationSystem", "runDerivator", "(", "Relation", "<", "ParameterizationFunction", ">", "relation", ",", "int", "dimensionality", ",", "DBIDs", "ids", ")", "{", "try", "{", "// build database for derivator", "Database", "derivatorDB", "=", "buildDerivatorDB", "(", "relation", ",", "ids", ")", ";", "PCARunner", "pca", "=", "new", "PCARunner", "(", "new", "StandardCovarianceMatrixBuilder", "(", ")", ")", ";", "EigenPairFilter", "filter", "=", "new", "FirstNEigenPairFilter", "(", "dimensionality", ")", ";", "DependencyDerivator", "<", "DoubleVector", ">", "derivator", "=", "new", "DependencyDerivator", "<>", "(", "null", ",", "FormatUtil", ".", "NF4", ",", "pca", ",", "filter", ",", "0", ",", "false", ")", ";", "CorrelationAnalysisSolution", "<", "DoubleVector", ">", "model", "=", "derivator", ".", "run", "(", "derivatorDB", ")", ";", "LinearEquationSystem", "les", "=", "model", ".", "getNormalizedLinearEquationSystem", "(", "null", ")", ";", "return", "les", ";", "}", "catch", "(", "NonNumericFeaturesException", "e", ")", "{", "throw", "new", "IllegalStateException", "(", "\"Error during normalization\"", "+", "e", ")", ";", "}", "}" ]

[ "Runs", "the", "derivator", "on", "the", "specified", "interval", "and", "assigns", "all", "points", "having", "a", "distance", "less", "then", "the", "standard", "deviation", "of", "the", "derivator", "model", "to", "the", "model", "to", "this", "model", "." ]

[ "protected", "TypeCodec", "<", "?", ">", "createCodec", "(", "GenericType", "<", "?", ">", "javaType", ",", "boolean", "isJavaCovariant", ")", "{", "TypeToken", "<", "?", ">", "token", "=", "javaType", ".", "__getToken", "(", ")", ";", "if", "(", "List", ".", "class", ".", "isAssignableFrom", "(", "token", ".", "getRawType", "(", ")", ")", "&&", "token", ".", "getType", "(", ")", "instanceof", "ParameterizedType", ")", "{", "Type", "[", "]", "typeArguments", "=", "(", "(", "ParameterizedType", ")", "token", ".", "getType", "(", ")", ")", ".", "getActualTypeArguments", "(", ")", ";", "GenericType", "<", "?", ">", "elementType", "=", "GenericType", ".", "of", "(", "typeArguments", "[", "0", "]", ")", ";", "TypeCodec", "<", "?", ">", "elementCodec", "=", "codecFor", "(", "elementType", ",", "isJavaCovariant", ")", ";", "return", "TypeCodecs", ".", "listOf", "(", "elementCodec", ")", ";", "}", "else", "if", "(", "Set", ".", "class", ".", "isAssignableFrom", "(", "token", ".", "getRawType", "(", ")", ")", "&&", "token", ".", "getType", "(", ")", "instanceof", "ParameterizedType", ")", "{", "Type", "[", "]", "typeArguments", "=", "(", "(", "ParameterizedType", ")", "token", ".", "getType", "(", ")", ")", ".", "getActualTypeArguments", "(", ")", ";", "GenericType", "<", "?", ">", "elementType", "=", "GenericType", ".", "of", "(", "typeArguments", "[", "0", "]", ")", ";", "TypeCodec", "<", "?", ">", "elementCodec", "=", "codecFor", "(", "elementType", ",", "isJavaCovariant", ")", ";", "return", "TypeCodecs", ".", "setOf", "(", "elementCodec", ")", ";", "}", "else", "if", "(", "Map", ".", "class", ".", "isAssignableFrom", "(", "token", ".", "getRawType", "(", ")", ")", "&&", "token", ".", "getType", "(", ")", "instanceof", "ParameterizedType", ")", "{", "Type", "[", "]", "typeArguments", "=", "(", "(", "ParameterizedType", ")", "token", ".", "getType", "(", ")", ")", ".", "getActualTypeArguments", "(", ")", ";", "GenericType", "<", "?", ">", "keyType", "=", "GenericType", ".", "of", "(", "typeArguments", "[", "0", "]", ")", ";", "GenericType", "<", "?", ">", "valueType", "=", "GenericType", ".", "of", "(", "typeArguments", "[", "1", "]", ")", ";", "TypeCodec", "<", "?", ">", "keyCodec", "=", "codecFor", "(", "keyType", ",", "isJavaCovariant", ")", ";", "TypeCodec", "<", "?", ">", "valueCodec", "=", "codecFor", "(", "valueType", ",", "isJavaCovariant", ")", ";", "return", "TypeCodecs", ".", "mapOf", "(", "keyCodec", ",", "valueCodec", ")", ";", "}", "throw", "new", "CodecNotFoundException", "(", "null", ",", "javaType", ")", ";", "}" ]

[ "Variant", "where", "the", "CQL", "type", "is", "unknown", ".", "Can", "be", "covariant", "if", "we", "come", "from", "a", "lookup", "by", "Java", "value", "." ]

[ "private", "synchronized", "void", "registerNamespace", "(", "String", "prefix", ",", "String", "uri", ",", "boolean", "persist", ")", "throws", "NamespaceException", ",", "RepositoryException", "{", "if", "(", "namespaces", ".", "containsKey", "(", "prefix", ")", ")", "{", "unregisterNamespace", "(", "prefix", ")", ";", "}", "else", "if", "(", "prefixes", ".", "containsKey", "(", "uri", ")", ")", "{", "unregisterNamespace", "(", "prefixes", ".", "get", "(", "uri", ")", ")", ";", "}", "if", "(", "persister", "!=", "null", "&&", "persist", ")", "{", "persister", ".", "addNamespace", "(", "prefix", ",", "uri", ")", ";", "}", "final", "String", "newPrefix", "=", "new", "String", "(", "prefix", ")", ";", "final", "String", "newUri", "=", "new", "String", "(", "uri", ")", ";", "namespaces", ".", "put", "(", "newPrefix", ",", "newUri", ")", ";", "prefixes", ".", "put", "(", "newUri", ",", "newPrefix", ")", ";", "}" ]

[ "Registers", "the", "namespace", "and", "persists", "it", "if", "<code", ">", "persist<", "/", "code", ">", "has", "been", "set", "to", "<code", ">", "true<", "/", "code", ">", "and", "a", "persister", "has", "been", "configured" ]

[ "public", "Binding", "toBinding", "(", "BindingElement", "element", ")", "{", "final", "TypeReference", "typeReference", "=", "typeRef", "(", "element", ".", "getBind", "(", ")", ")", ";", "final", "String", "annotatedWith", "=", "element", ".", "getAnnotatedWith", "(", ")", ";", "final", "String", "annotatedWithName", "=", "element", ".", "getAnnotatedWithName", "(", ")", ";", "if", "(", "!", "Strings", ".", "isEmpty", "(", "annotatedWith", ")", ")", "{", "final", "TypeReference", "annotationType", "=", "typeRef", "(", "annotatedWith", ")", ";", "if", "(", "element", ".", "isInstance", "(", ")", ")", "{", "return", "bindAnnotatedWithToInstance", "(", "typeReference", ",", "annotationType", ",", "element", ".", "getTo", "(", ")", ",", "element", ".", "getFunctionName", "(", ")", ")", ";", "}", "final", "TypeReference", "typeReference2", "=", "typeRef", "(", "element", ".", "getTo", "(", ")", ")", ";", "return", "bindAnnotatedWith", "(", "typeReference", ",", "annotationType", ",", "typeReference2", ",", "element", ".", "getFunctionName", "(", ")", ")", ";", "}", "if", "(", "!", "Strings", ".", "isEmpty", "(", "annotatedWithName", ")", ")", "{", "if", "(", "element", ".", "isInstance", "(", ")", ")", "{", "return", "bindAnnotatedWithNameToInstance", "(", "typeReference", ",", "annotatedWithName", ",", "element", ".", "getTo", "(", ")", ",", "element", ".", "getFunctionName", "(", ")", ")", ";", "}", "final", "TypeReference", "typeReference2", "=", "typeRef", "(", "element", ".", "getTo", "(", ")", ")", ";", "return", "bindAnnotatedWithName", "(", "typeReference", ",", "annotatedWithName", ",", "typeReference2", ",", "element", ".", "getFunctionName", "(", ")", ")", ";", "}", "if", "(", "element", ".", "isInstance", "(", ")", ")", "{", "return", "bindToInstance", "(", "typeReference", ",", "element", ".", "getFunctionName", "(", ")", ",", "element", ".", "getTo", "(", ")", ",", "element", ".", "isSingleton", "(", ")", ",", "element", ".", "isEager", "(", ")", ")", ";", "}", "final", "TypeReference", "typeReference2", "=", "typeRef", "(", "element", ".", "getTo", "(", ")", ")", ";", "return", "bindToType", "(", "typeReference", ",", "element", ".", "getFunctionName", "(", ")", ",", "typeReference2", ",", "element", ".", "isSingleton", "(", ")", ",", "element", ".", "isEager", "(", ")", ",", "element", ".", "isProvider", "(", ")", ")", ";", "}" ]

[ "Convert", "a", "binding", "element", "to", "a", "Guive", "binding", "." ]

[ "protected", "Object", "get", "(", "int", "access", ",", "String", "name", ",", "Object", "defaultValue", ")", "{", "return", "get", "(", "access", ",", "KeyImpl", ".", "init", "(", "name", ")", ",", "defaultValue", ")", ";", "}" ]

[ "return", "element", "that", "has", "at", "least", "given", "access", "or", "null" ]

[ "protected", "Field", "getField", "(", "Class", "type", ",", "String", "name", ")", "{", "return", "introspector", "(", "type", ")", ".", "getField", "(", "toJavaIdentifierForm", "(", "name", ")", ")", ";", "}" ]

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

[ "public", "static", "String", "getRequiredCheck", "(", "int", "order", ",", "Field", "field", ")", "{", "String", "fieldName", "=", "getFieldName", "(", "order", ")", ";", "String", "code", "=", "\"if (\"", "+", "fieldName", "+", "\"== null) {\\n\"", ";", "code", "+=", "\"throw new UninitializedMessageException(CodedConstant.asList(\\\"\"", "+", "field", ".", "getName", "(", ")", "+", "\"\\\"))\"", "+", "ClassCode", ".", "JAVA_LINE_BREAK", ";", "code", "+=", "\"}\\n\"", ";", "return", "code", ";", "}" ]

[ "get", "required", "field", "check", "java", "expression", "." ]

[ "@", "Nonnull", "@", "ReturnsMutableCopy", "public", "static", "<", "ELEMENTTYPE", ">", "ELEMENTTYPE", "[", "]", "getConcatenated", "(", "@", "Nullable", "final", "ELEMENTTYPE", "[", "]", "aHeadArray", ",", "@", "Nullable", "final", "ELEMENTTYPE", "aTail", ",", "@", "Nonnull", "final", "Class", "<", "ELEMENTTYPE", ">", "aClass", ")", "{", "if", "(", "isEmpty", "(", "aHeadArray", ")", ")", "return", "newArraySingleElement", "(", "aTail", ",", "aClass", ")", ";", "// Start concatenating", "final", "ELEMENTTYPE", "[", "]", "ret", "=", "newArray", "(", "aClass", ",", "aHeadArray", ".", "length", "+", "1", ")", ";", "System", ".", "arraycopy", "(", "aHeadArray", ",", "0", ",", "ret", ",", "0", ",", "aHeadArray", ".", "length", ")", ";", "ret", "[", "aHeadArray", ".", "length", "]", "=", "aTail", ";", "return", "ret", ";", "}" ]

[ "Get", "a", "new", "array", "that", "combines", "the", "passed", "array", "and", "the", "tail", "element", ".", "The", "tail", "element", "will", "be", "the", "last", "element", "of", "the", "created", "array", "." ]

[ "public", "void", "setRelations", "(", "int", "i", ",", "Relation", "v", ")", "{", "if", "(", "Document_Type", ".", "featOkTst", "&&", "(", "(", "Document_Type", ")", "jcasType", ")", ".", "casFeat_relations", "==", "null", ")", "jcasType", ".", "jcas", ".", "throwFeatMissing", "(", "\"relations\"", ",", "\"de.julielab.jules.types.ace.Document\"", ")", ";", "jcasType", ".", "jcas", ".", "checkArrayBounds", "(", "jcasType", ".", "ll_cas", ".", "ll_getRefValue", "(", "addr", ",", "(", "(", "Document_Type", ")", "jcasType", ")", ".", "casFeatCode_relations", ")", ",", "i", ")", ";", "jcasType", ".", "ll_cas", ".", "ll_setRefArrayValue", "(", "jcasType", ".", "ll_cas", ".", "ll_getRefValue", "(", "addr", ",", "(", "(", "Document_Type", ")", "jcasType", ")", ".", "casFeatCode_relations", ")", ",", "i", ",", "jcasType", ".", "ll_cas", ".", "ll_getFSRef", "(", "v", ")", ")", ";", "}" ]

[ "indexed", "setter", "for", "relations", "-", "sets", "an", "indexed", "value", "-" ]

[ "public", "static", "<", "T", ">", "int", "binarySearch", "(", "List", "<", "?", "extends", "T", ">", "list", ",", "Function", "<", "?", "super", "T", ",", "Integer", ">", "comparator", ")", "{", "return", "binarySearch", "(", "list", ",", "comparator", ",", "false", ")", ";", "}" ]

[ "Performs", "a", "binary", "search", "on", "the", "given", "sorted", "list", "using", "the", "given", "comparator", ".", "This", "method", "has", "undefined", "behavior", "if", "the", "list", "is", "not", "sorted", ".", "<p", ">", "This", "method", "is", "different", "than", "that", "in", "java", ".", "util", ".", "Collections", "in", "the", "following", "ways", ":", "1", ".", "This", "one", "searches", "by", "a", "simple", "comparator", "vs", "the", "ones", "in", "the", "Collections", "class", "which", "search", "for", "a", "specific", "element", ".", "This", "one", "is", "useful", "if", "we", "don", "t", "have", "an", "instance", "of", "a", "search", "object", "or", "we", "want", "to", "implement", "a", "fuzzy", "comparison", ".", "2", ".", "This", "one", "returns", "-", "1", "if", "the", "element", "is", "not", "found", ".", "The", "ones", "in", "the", "Collections", "class", "return", "(", "-", "(", "start", "+", "1", "))", "which", "is", "the", "index", "where", "the", "item", "should", "be", "inserted", "if", "it", "were", "to", "go", "in", "the", "list", "." ]

[ "protected", "void", "substituteSymbols", "(", "Map", "<", "String", ",", "String", ">", "initProps", ")", "{", "for", "(", "Entry", "<", "String", ",", "String", ">", "entry", ":", "initProps", ".", "entrySet", "(", ")", ")", "{", "Object", "value", "=", "entry", ".", "getValue", "(", ")", ";", "if", "(", "value", "instanceof", "String", ")", "{", "String", "strValue", "=", "(", "String", ")", "value", ";", "Matcher", "m", "=", "SYMBOL_DEF", ".", "matcher", "(", "strValue", ")", ";", "int", "i", "=", "0", ";", "while", "(", "m", ".", "find", "(", ")", "&&", "i", "++", "<", "4", ")", "{", "String", "symbol", "=", "m", ".", "group", "(", "1", ")", ";", "Object", "expansion", "=", "initProps", ".", "get", "(", "symbol", ")", ";", "if", "(", "expansion", "!=", "null", "&&", "expansion", "instanceof", "String", ")", "{", "strValue", "=", "strValue", ".", "replace", "(", "m", ".", "group", "(", "0", ")", ",", "(", "String", ")", "expansion", ")", ";", "entry", ".", "setValue", "(", "strValue", ")", ";", "}", "}", "}", "}", "}" ]

[ "Perform", "substitution", "of", "symbols", "used", "in", "config" ]

[ "private", "T", "createOrThrow", "(", "String", "name", ")", "{", "T", "constant", "=", "constants", ".", "get", "(", "name", ")", ";", "if", "(", "constant", "==", "null", ")", "{", "final", "T", "tempConstant", "=", "newConstant", "(", "nextId", "(", ")", ",", "name", ")", ";", "constant", "=", "constants", ".", "putIfAbsent", "(", "name", ",", "tempConstant", ")", ";", "if", "(", "constant", "==", "null", ")", "{", "return", "tempConstant", ";", "}", "}", "throw", "new", "IllegalArgumentException", "(", "String", ".", "format", "(", "\"'%s' is already in use\"", ",", "name", ")", ")", ";", "}" ]

[ "Creates", "constant", "by", "name", "or", "throws", "exception", ".", "Threadsafe" ]

[ "public", "GetFunctionDefinitionResult", "withTags", "(", "java", ".", "util", ".", "Map", "<", "String", ",", "String", ">", "tags", ")", "{", "setTags", "(", "tags", ")", ";", "return", "this", ";", "}" ]

[ "The", "tags", "for", "the", "definition", "." ]

[ "public", "static", "<", "T", ">", "T", "createInstance", "(", "Class", "<", "T", ">", "type", ",", "Object", "...", "parameters", ")", "{", "// get types for parameters", "Class", "<", "?", ">", "[", "]", "parameterTypes", "=", "new", "Class", "<", "?", ">", "[", "parameters", ".", "length", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "parameters", ".", "length", ";", "i", "++", ")", "{", "Object", "parameter", "=", "parameters", "[", "i", "]", ";", "parameterTypes", "[", "i", "]", "=", "parameter", ".", "getClass", "(", ")", ";", "}", "try", "{", "// create instance", "Constructor", "<", "T", ">", "constructor", "=", "type", ".", "getConstructor", "(", "parameterTypes", ")", ";", "return", "constructor", ".", "newInstance", "(", "parameters", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "ModelException", "(", "\"Exception while creating an instance of type \"", "+", "type", ",", "e", ")", ";", "}", "}" ]

[ "Create", "a", "new", "instance", "of", "the", "provided", "type" ]

[ "public", "static", "int", "importData", "(", "final", "DataSet", "dataset", ",", "final", "PreparedStatement", "stmt", ")", "throws", "UncheckedSQLException", "{", "return", "importData", "(", "dataset", ",", "dataset", ".", "columnNameList", "(", ")", ",", "stmt", ")", ";", "}" ]

[ "Imports", "the", "data", "from", "<code", ">", "DataSet<", "/", "code", ">", "to", "database", "." ]

[ "public", "static", "S3Objects", "withPrefix", "(", "AmazonS3", "s3", ",", "String", "bucketName", ",", "String", "prefix", ")", "{", "S3Objects", "objects", "=", "new", "S3Objects", "(", "s3", ",", "bucketName", ")", ";", "objects", ".", "prefix", "=", "prefix", ";", "return", "objects", ";", "}" ]

[ "Constructs", "an", "iterable", "that", "covers", "the", "objects", "in", "an", "Amazon", "S3", "bucket", "where", "the", "key", "begins", "with", "the", "given", "prefix", "." ]

[ "public", "static", "<", "II", "extends", "ImageGray", "<", "II", ">", ">", "void", "harder", "(", "GrayF32", "image", ")", "{", "// SURF works off of integral images", "Class", "<", "II", ">", "integralType", "=", "GIntegralImageOps", ".", "getIntegralType", "(", "GrayF32", ".", "class", ")", ";", "// define the feature detection algorithm", "NonMaxSuppression", "extractor", "=", "FactoryFeatureExtractor", ".", "nonmax", "(", "new", "ConfigExtract", "(", "2", ",", "0", ",", "5", ",", "true", ")", ")", ";", "FastHessianFeatureDetector", "<", "II", ">", "detector", "=", "new", "FastHessianFeatureDetector", "<>", "(", "extractor", ",", "200", ",", "2", ",", "9", ",", "4", ",", "4", ",", "6", ")", ";", "// estimate orientation", "OrientationIntegral", "<", "II", ">", "orientation", "=", "FactoryOrientationAlgs", ".", "sliding_ii", "(", "null", ",", "integralType", ")", ";", "DescribePointSurf", "<", "II", ">", "descriptor", "=", "FactoryDescribePointAlgs", ".", "<", "II", ">", "surfStability", "(", "null", ",", "integralType", ")", ";", "// compute the integral image of 'image'", "II", "integral", "=", "GeneralizedImageOps", ".", "createSingleBand", "(", "integralType", ",", "image", ".", "width", ",", "image", ".", "height", ")", ";", "GIntegralImageOps", ".", "transform", "(", "image", ",", "integral", ")", ";", "// detect fast hessian features", "detector", ".", "detect", "(", "integral", ")", ";", "// tell algorithms which image to process", "orientation", ".", "setImage", "(", "integral", ")", ";", "descriptor", ".", "setImage", "(", "integral", ")", ";", "List", "<", "ScalePoint", ">", "points", "=", "detector", ".", "getFoundPoints", "(", ")", ";", "List", "<", "BrightFeature", ">", "descriptions", "=", "new", "ArrayList", "<>", "(", ")", ";", "for", "(", "ScalePoint", "p", ":", "points", ")", "{", "// estimate orientation", "orientation", ".", "setObjectRadius", "(", "p", ".", "scale", "*", "BoofDefaults", ".", "SURF_SCALE_TO_RADIUS", ")", ";", "double", "angle", "=", "orientation", ".", "compute", "(", "p", ".", "x", ",", "p", ".", "y", ")", ";", "// extract the SURF description for this region", "BrightFeature", "desc", "=", "descriptor", ".", "createDescription", "(", ")", ";", "descriptor", ".", "describe", "(", "p", ".", "x", ",", "p", ".", "y", ",", "angle", ",", "p", ".", "scale", ",", "desc", ")", ";", "// save everything for processing later on", "descriptions", ".", "add", "(", "desc", ")", ";", "}", "System", ".", "out", ".", "println", "(", "\"Found Features: \"", "+", "points", ".", "size", "(", ")", ")", ";", "System", ".", "out", ".", "println", "(", "\"First descriptor's first value: \"", "+", "descriptions", ".", "get", "(", "0", ")", ".", "value", "[", "0", "]", ")", ";", "}" ]

[ "Configured", "exactly", "the", "same", "as", "the", "easy", "example", "above", "but", "require", "a", "lot", "more", "code", "and", "a", "more", "in", "depth", "understanding", "of", "how", "SURF", "works", "and", "is", "configured", ".", "Instead", "of", "TupleDesc_F64", "SurfFeature", "are", "computed", "in", "this", "case", ".", "They", "are", "almost", "the", "same", "as", "TupleDesc_F64", "but", "contain", "the", "Laplacian", "s", "sign", "which", "can", "be", "used", "to", "speed", "up", "association", ".", "That", "is", "an", "example", "of", "how", "using", "less", "generalized", "interfaces", "can", "improve", "performance", "." ]

[ "public", "Observable", "<", "IntegrationAccountCertificateInner", ">", "createOrUpdateAsync", "(", "String", "resourceGroupName", ",", "String", "integrationAccountName", ",", "String", "certificateName", ",", "IntegrationAccountCertificateInner", "certificate", ")", "{", "return", "createOrUpdateWithServiceResponseAsync", "(", "resourceGroupName", ",", "integrationAccountName", ",", "certificateName", ",", "certificate", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "IntegrationAccountCertificateInner", ">", ",", "IntegrationAccountCertificateInner", ">", "(", ")", "{", "@", "Override", "public", "IntegrationAccountCertificateInner", "call", "(", "ServiceResponse", "<", "IntegrationAccountCertificateInner", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Creates", "or", "updates", "an", "integration", "account", "certificate", "." ]

[ "public", "<", "T", "extends", "ICDKObject", ">", "T", "ofClass", "(", "Class", "<", "T", ">", "intf", ",", "Object", "...", "objects", ")", "{", "try", "{", "if", "(", "!", "intf", ".", "isInterface", "(", ")", ")", "throw", "new", "IllegalArgumentException", "(", "\"expected interface, got \"", "+", "intf", ".", "getClass", "(", ")", ")", ";", "Creator", "<", "T", ">", "constructor", "=", "get", "(", "new", "ObjectBasedKey", "(", "intf", ",", "objects", ")", ")", ";", "return", "constructor", ".", "create", "(", "objects", ")", ";", "}", "catch", "(", "InstantiationException", "e", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"unable to instantiate chem object: \"", ",", "e", ")", ";", "}", "catch", "(", "IllegalAccessException", "e", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"constructor is not accessible: \"", ",", "e", ")", ";", "}", "catch", "(", "InvocationTargetException", "e", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"invocation target exception: \"", ",", "e", ")", ";", "}", "}" ]

[ "Construct", "an", "implementation", "using", "a", "constructor", "whose", "parameters", "match", "that", "of", "the", "provided", "objects", "." ]

[ "public", "void", "incrementCounts", "(", "Collection", "<", "E", ">", "keys", ",", "int", "count", ")", "{", "for", "(", "E", "key", ":", "keys", ")", "{", "incrementCount", "(", "key", ",", "count", ")", ";", "}", "}" ]

[ "Adds", "the", "given", "count", "to", "the", "current", "counts", "for", "each", "of", "the", "given", "keys", ".", "If", "any", "of", "the", "keys", "haven", "t", "been", "seen", "before", "they", "are", "assumed", "to", "have", "count", "0", "and", "thus", "this", "method", "will", "set", "their", "counts", "to", "the", "given", "amount", ".", "Negative", "increments", "are", "equivalent", "to", "calling", "<tt", ">", "decrementCounts<", "/", "tt", ">", ".", "<p", "/", ">", "To", "more", "conveniently", "increment", "the", "counts", "of", "a", "collection", "of", "objects", "by", "1", "use", "{" ]

[ "public", "static", "<", "X", ",", "CX", "extends", "Collection", "<", "X", ">", ">", "Lens", ".", "Simple", "<", "CX", ",", "CX", ">", "asCopy", "(", "Function", "<", "?", "super", "CX", ",", "?", "extends", "CX", ">", "copyFn", ")", "{", "return", "simpleLens", "(", "copyFn", ",", "(", "__", ",", "copy", ")", "->", "copy", ")", ";", "}" ]

[ "Convenience", "static", "factory", "method", "for", "creating", "a", "lens", "that", "focuses", "on", "a", "copy", "of", "a", "<code", ">", "Collection<", "/", "code", ">", "given", "a", "function", "that", "creates", "the", "copy", ".", "Useful", "for", "composition", "to", "avoid", "mutating", "a", "<code", ">", "Collection<", "/", "code", ">", "reference", "." ]

[ "public", "void", "addLink", "(", "final", "String", "path", ",", "final", "String", "target", ")", "throws", "NoSuchAlgorithmException", ",", "IOException", "{", "contents", ".", "addLink", "(", "path", ",", "target", ")", ";", "}" ]

[ "Adds", "a", "symbolic", "link", "to", "the", "repository", "." ]

[ "private", "boolean", "isAnomaly", "(", "Instance", "instance", ",", "ActiveRule", "rule", ")", "{", "//AMRUles is equipped with anomaly detection. If on, compute the anomaly value. \t\t\t", "boolean", "isAnomaly", "=", "false", ";", "if", "(", "this", ".", "noAnomalyDetection", "==", "false", ")", "{", "if", "(", "rule", ".", "getInstancesSeen", "(", ")", ">=", "this", ".", "anomalyNumInstThreshold", ")", "{", "isAnomaly", "=", "rule", ".", "isAnomaly", "(", "instance", ",", "this", ".", "univariateAnomalyprobabilityThreshold", ",", "this", ".", "multivariateAnomalyProbabilityThreshold", ",", "this", ".", "anomalyNumInstThreshold", ")", ";", "}", "}", "return", "isAnomaly", ";", "}" ]

[ "Method", "to", "verify", "if", "the", "instance", "is", "an", "anomaly", "." ]

[ "private", "Double", "scale", "(", "Double", "value", ",", "Double", "maxAbsolute", ")", "{", "if", "(", "maxAbsolute", ".", "equals", "(", "0.0", ")", ")", "{", "return", "Math", ".", "signum", "(", "value", ")", ";", "}", "else", "{", "return", "value", "/", "maxAbsolute", ";", "}", "}" ]

[ "Performs", "the", "actual", "rescaling", "handling", "corner", "cases", "." ]

[ "public", "IEntityLock", "newReadLock", "(", "Class", "entityType", ",", "String", "entityKey", ",", "String", "owner", ")", "throws", "LockingException", "{", "return", "lockService", ".", "newLock", "(", "entityType", ",", "entityKey", ",", "IEntityLockService", ".", "READ_LOCK", ",", "owner", ")", ";", "}" ]

[ "Returns", "a", "read", "lock", "for", "the", "entity", "type", "entity", "key", "and", "owner", "." ]

[ "public", "static", "BaseResult", "userInfoUpdateremark", "(", "String", "access_token", ",", "String", "openid", ",", "String", "remark", ")", "{", "String", "postJson", "=", "String", ".", "format", "(", "\"{\\\"openid\\\":\\\"%1$s\\\",\\\"remark\\\":\\\"%2$s\\\"}\"", ",", "openid", ",", "remark", ")", ";", "HttpUriRequest", "httpUriRequest", "=", "RequestBuilder", ".", "post", "(", ")", ".", "setHeader", "(", "jsonHeader", ")", ".", "setUri", "(", "BASE_URI", "+", "\"/cgi-bin/user/info/updateremark\"", ")", ".", "addParameter", "(", "PARAM_ACCESS_TOKEN", ",", "API", ".", "accessToken", "(", "access_token", ")", ")", ".", "setEntity", "(", "new", "StringEntity", "(", "postJson", ",", "Charset", ".", "forName", "(", "\"utf-8\"", ")", ")", ")", ".", "build", "(", ")", ";", "return", "LocalHttpClient", ".", "executeJsonResult", "(", "httpUriRequest", ",", "BaseResult", ".", "class", ")", ";", "}" ]

[ "设置备注名" ]

[ "public", "static", "TypeDeclarationNode", "functionType", "(", "Node", "returnType", ",", "LinkedHashMap", "<", "String", ",", "TypeDeclarationNode", ">", "requiredParams", ",", "LinkedHashMap", "<", "String", ",", "TypeDeclarationNode", ">", "optionalParams", ",", "String", "restName", ",", "TypeDeclarationNode", "restType", ")", "{", "TypeDeclarationNode", "node", "=", "new", "TypeDeclarationNode", "(", "Token", ".", "FUNCTION_TYPE", ",", "returnType", ")", ";", "checkNotNull", "(", "requiredParams", ")", ";", "checkNotNull", "(", "optionalParams", ")", ";", "for", "(", "Map", ".", "Entry", "<", "String", ",", "TypeDeclarationNode", ">", "param", ":", "requiredParams", ".", "entrySet", "(", ")", ")", "{", "Node", "name", "=", "IR", ".", "name", "(", "param", ".", "getKey", "(", ")", ")", ";", "node", ".", "addChildToBack", "(", "maybeAddType", "(", "name", ",", "param", ".", "getValue", "(", ")", ")", ")", ";", "}", "for", "(", "Map", ".", "Entry", "<", "String", ",", "TypeDeclarationNode", ">", "param", ":", "optionalParams", ".", "entrySet", "(", ")", ")", "{", "Node", "name", "=", "IR", ".", "name", "(", "param", ".", "getKey", "(", ")", ")", ";", "name", ".", "putBooleanProp", "(", "Node", ".", "OPT_ES6_TYPED", ",", "true", ")", ";", "node", ".", "addChildToBack", "(", "maybeAddType", "(", "name", ",", "param", ".", "getValue", "(", ")", ")", ")", ";", "}", "if", "(", "restName", "!=", "null", ")", "{", "Node", "rest", "=", "new", "Node", "(", "Token", ".", "REST", ",", "IR", ".", "name", "(", "restName", ")", ")", ";", "node", ".", "addChildToBack", "(", "maybeAddType", "(", "rest", ",", "restType", ")", ")", ";", "}", "return", "node", ";", "}" ]

[ "Represents", "a", "function", "type", ".", "Closure", "has", "syntax", "like", "{", "@code", "{", "function", "(", "string", "boolean", ")", ":", "number", "}}", "Closure", "doesn", "t", "include", "parameter", "names", ".", "If", "the", "parameter", "types", "are", "unnamed", "arbitrary", "names", "can", "be", "substituted", "eg", ".", "p1", "p2", "etc", "." ]

[ "public", "<", "R", "extends", "JmxRequest", ">", "Object", "handleRequest", "(", "JsonRequestHandler", "<", "R", ">", "pRequestHandler", ",", "R", "pJmxReq", ")", "throws", "MBeanException", ",", "ReflectionException", ",", "AttributeNotFoundException", ",", "InstanceNotFoundException", ",", "NotChangedException", "{", "AttributeNotFoundException", "attrException", "=", "null", ";", "InstanceNotFoundException", "objNotFoundException", "=", "null", ";", "for", "(", "MBeanServerConnection", "conn", ":", "getMBeanServers", "(", ")", ")", "{", "try", "{", "return", "pRequestHandler", ".", "handleRequest", "(", "conn", ",", "pJmxReq", ")", ";", "}", "catch", "(", "InstanceNotFoundException", "exp", ")", "{", "// Remember exceptions for later use", "objNotFoundException", "=", "exp", ";", "}", "catch", "(", "AttributeNotFoundException", "exp", ")", "{", "attrException", "=", "exp", ";", "}", "catch", "(", "IOException", "exp", ")", "{", "throw", "new", "IllegalStateException", "(", "\"I/O Error while dispatching\"", ",", "exp", ")", ";", "}", "}", "if", "(", "attrException", "!=", "null", ")", "{", "throw", "attrException", ";", "}", "// Must be there, otherwise we would not have left the loop", "throw", "objNotFoundException", ";", "}" ]

[ "Handle", "a", "single", "request" ]

[ "public", "OvhEmailAvailability", "localSeo_emailAvailability_GET", "(", "String", "email", ")", "throws", "IOException", "{", "String", "qPath", "=", "\"/hosting/web/localSeo/emailAvailability\"", ";", "StringBuilder", "sb", "=", "path", "(", "qPath", ")", ";", "query", "(", "sb", ",", "\"email\"", ",", "email", ")", ";", "String", "resp", "=", "execN", "(", "qPath", ",", "\"GET\"", ",", "sb", ".", "toString", "(", ")", ",", "null", ")", ";", "return", "convertTo", "(", "resp", ",", "OvhEmailAvailability", ".", "class", ")", ";", "}" ]

[ "Check", "email", "availability", "for", "a", "local", "SEO", "order" ]

[ "public", "final", "URL", "getBinaryDict", "(", "final", "String", "lang", ",", "final", "String", "resourcesDirectory", ")", "{", "return", "resourcesDirectory", "==", "null", "?", "getBinaryDictFromResources", "(", "lang", ")", ":", "getBinaryDictFromDirectory", "(", "lang", ",", "resourcesDirectory", ")", ";", "}" ]

[ "The", "the", "dictionary", "for", "the", "{", "@code", "MorfologikLemmatizer", "}", "." ]

[ "@", "UiThread", "public", "void", "notifyParentMoved", "(", "int", "fromParentPosition", ",", "int", "toParentPosition", ")", "{", "int", "fromFlatParentPosition", "=", "getFlatParentPosition", "(", "fromParentPosition", ")", ";", "ExpandableWrapper", "<", "P", ",", "C", ">", "fromParentWrapper", "=", "mFlatItemList", ".", "get", "(", "fromFlatParentPosition", ")", ";", "// If the parent is collapsed we can take advantage of notifyItemMoved otherwise", "// we are forced to do a \"manual\" move by removing and then adding the parent + children", "// (no notifyItemRangeMovedAvailable)", "boolean", "isCollapsed", "=", "!", "fromParentWrapper", ".", "isExpanded", "(", ")", ";", "boolean", "isExpandedNoChildren", "=", "!", "isCollapsed", "&&", "(", "fromParentWrapper", ".", "getWrappedChildList", "(", ")", ".", "size", "(", ")", "==", "0", ")", ";", "if", "(", "isCollapsed", "||", "isExpandedNoChildren", ")", "{", "int", "toFlatParentPosition", "=", "getFlatParentPosition", "(", "toParentPosition", ")", ";", "ExpandableWrapper", "<", "P", ",", "C", ">", "toParentWrapper", "=", "mFlatItemList", ".", "get", "(", "toFlatParentPosition", ")", ";", "mFlatItemList", ".", "remove", "(", "fromFlatParentPosition", ")", ";", "int", "childOffset", "=", "0", ";", "if", "(", "toParentWrapper", ".", "isExpanded", "(", ")", ")", "{", "childOffset", "=", "toParentWrapper", ".", "getWrappedChildList", "(", ")", ".", "size", "(", ")", ";", "}", "mFlatItemList", ".", "add", "(", "toFlatParentPosition", "+", "childOffset", ",", "fromParentWrapper", ")", ";", "notifyItemMoved", "(", "fromFlatParentPosition", ",", "toFlatParentPosition", "+", "childOffset", ")", ";", "}", "else", "{", "// Remove the parent and children", "int", "sizeChanged", "=", "0", ";", "int", "childListSize", "=", "fromParentWrapper", ".", "getWrappedChildList", "(", ")", ".", "size", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "childListSize", "+", "1", ";", "i", "++", ")", "{", "mFlatItemList", ".", "remove", "(", "fromFlatParentPosition", ")", ";", "sizeChanged", "++", ";", "}", "notifyItemRangeRemoved", "(", "fromFlatParentPosition", ",", "sizeChanged", ")", ";", "// Add the parent and children at new position", "int", "toFlatParentPosition", "=", "getFlatParentPosition", "(", "toParentPosition", ")", ";", "int", "childOffset", "=", "0", ";", "if", "(", "toFlatParentPosition", "!=", "INVALID_FLAT_POSITION", ")", "{", "ExpandableWrapper", "<", "P", ",", "C", ">", "toParentWrapper", "=", "mFlatItemList", ".", "get", "(", "toFlatParentPosition", ")", ";", "if", "(", "toParentWrapper", ".", "isExpanded", "(", ")", ")", "{", "childOffset", "=", "toParentWrapper", ".", "getWrappedChildList", "(", ")", ".", "size", "(", ")", ";", "}", "}", "else", "{", "toFlatParentPosition", "=", "mFlatItemList", ".", "size", "(", ")", ";", "}", "mFlatItemList", ".", "add", "(", "toFlatParentPosition", "+", "childOffset", ",", "fromParentWrapper", ")", ";", "List", "<", "ExpandableWrapper", "<", "P", ",", "C", ">", ">", "wrappedChildList", "=", "fromParentWrapper", ".", "getWrappedChildList", "(", ")", ";", "sizeChanged", "=", "wrappedChildList", ".", "size", "(", ")", "+", "1", ";", "mFlatItemList", ".", "addAll", "(", "toFlatParentPosition", "+", "childOffset", "+", "1", ",", "wrappedChildList", ")", ";", "notifyItemRangeInserted", "(", "toFlatParentPosition", "+", "childOffset", ",", "sizeChanged", ")", ";", "}", "}" ]

[ "Notify", "any", "registered", "observers", "that", "the", "parent", "and", "its", "children", "reflected", "at", "{", "@code", "fromParentPosition", "}", "has", "been", "moved", "to", "{", "@code", "toParentPosition", "}", ".", "<p", ">", "<p", ">", "This", "is", "a", "structural", "change", "event", ".", "Representations", "of", "other", "existing", "items", "in", "the", "data", "set", "are", "still", "considered", "up", "to", "date", "and", "will", "not", "be", "rebound", "though", "their", "positions", "may", "be", "altered", ".", "<", "/", "p", ">" ]

[ "public", "void", "updateTreeContent", "(", "List", "<", "CmsGalleryTreeEntry", ">", "galleryTreeEntries", ",", "List", "<", "String", ">", "selectedGalleries", ")", "{", "clearList", "(", ")", ";", "m_selectedGalleries", "=", "selectedGalleries", ";", "if", "(", "!", "galleryTreeEntries", ".", "isEmpty", "(", ")", ")", "{", "m_itemIterator", "=", "new", "TreeItemGenerator", "(", "galleryTreeEntries", ")", ";", "loadMoreItems", "(", ")", ";", "}", "else", "{", "showIsEmptyLabel", "(", ")", ";", "}", "onContentChange", "(", ")", ";", "}" ]

[ "Update", "the", "galleries", "tree", ".", "<p", ">" ]

[ "@", "Deprecated", "final", "static", "public", "void", "spacePad", "(", "StringBuffer", "sbuf", ",", "int", "length", ")", "{", "while", "(", "length", ">=", "32", ")", "{", "sbuf", ".", "append", "(", "SPACES", "[", "5", "]", ")", ";", "length", "-=", "32", ";", "}", "for", "(", "int", "i", "=", "4", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "(", "length", "&", "(", "1", "<<", "i", ")", ")", "!=", "0", ")", "{", "sbuf", ".", "append", "(", "SPACES", "[", "i", "]", ")", ";", "}", "}", "}" ]

[ "Fast", "space", "padding", "method", "." ]

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

[ "Retrieve", "the", "Dsc", "configuration", "compilation", "job", "identified", "by", "job", "id", "." ]