Datasets:

stojchet

/

2-csn_java_python_subset

like 0

[ "protected", "StringConcatenationClient", "generateMembersFromConfig", "(", "Set", "<", "String", ">", "addedKeywords", ",", "Map", "<", "String", ",", "String", ">", "getters", ")", "{", "final", "List", "<", "StringConcatenationClient", ">", "clients", "=", "new", "ArrayList", "<>", "(", ")", ";", "for", "(", "final", "String", "keyword", ":", "this", ".", "configuration", ".", "getKeywords", "(", ")", ")", "{", "final", "String", "id", "=", "keyword", ".", "toLowerCase", "(", ")", ";", "if", "(", "!", "addedKeywords", ".", "contains", "(", "id", ")", "&&", "!", "this", ".", "configuration", ".", "getIgnoredKeywords", "(", ")", ".", "contains", "(", "keyword", ")", ")", "{", "clients", ".", "add", "(", "generateKeyword", "(", "keyword", ",", "getGrammar", "(", ")", ".", "getName", "(", ")", ",", "getters", ")", ")", ";", "addedKeywords", ".", "add", "(", "id", ")", ";", "}", "}", "for", "(", "final", "String", "keyword", ":", "this", ".", "configuration", ".", "getLiterals", "(", ")", ")", "{", "final", "String", "id", "=", "keyword", ".", "toLowerCase", "(", ")", ";", "if", "(", "!", "addedKeywords", ".", "contains", "(", "id", ")", "&&", "!", "this", ".", "configuration", ".", "getIgnoredKeywords", "(", ")", ".", "contains", "(", "keyword", ")", ")", "{", "clients", ".", "add", "(", "generateKeyword", "(", "keyword", ",", "getGrammar", "(", ")", ".", "getName", "(", ")", ",", "getters", ")", ")", ";", "addedKeywords", ".", "add", "(", "id", ")", ";", "}", "}", "return", "new", "StringConcatenationClient", "(", ")", "{", "@", "Override", "protected", "void", "appendTo", "(", "TargetStringConcatenation", "it", ")", "{", "for", "(", "final", "StringConcatenationClient", "client", ":", "clients", ")", "{", "it", ".", "append", "(", "client", ")", ";", "}", "}", "}", ";", "}" ]

[ "Generate", "the", "members", "of", "the", "accessors", "." ]

[ "public", "static", "Object", "deepBox", "(", "Object", "src", ")", "{", "Class", "<", "?", ">", "resultType", "=", "arrayBoxingType", "(", "src", ".", "getClass", "(", ")", ")", ";", "return", "deepBox", "(", "resultType", ",", "src", ")", ";", "}" ]

[ "Returns", "any", "multidimensional", "array", "into", "an", "array", "of", "boxed", "values", "." ]

[ "public", "void", "setTrack", "(", "int", "track", ",", "int", "type", ")", "{", "if", "(", "allow", "(", "type", "&", "ID3V1", ")", ")", "{", "id3v1", ".", "setTrack", "(", "track", ")", ";", "}", "if", "(", "allow", "(", "type", "&", "ID3V2", ")", ")", "{", "id3v2", ".", "setTextFrame", "(", "ID3v2Frames", ".", "TRACK_NUMBER", ",", "String", ".", "valueOf", "(", "track", ")", ")", ";", "}", "}" ]

[ "Set", "the", "track", "number", "of", "this", "mp3", "." ]

[ "void", "printDotNodesAtLevel", "(", "PrintStream", "os", ",", "int", "levelToPrint", ",", "boolean", "detail", ",", "PrintMojo", ".", "PrintTreeOptions", "treeOptions", ")", "{", "if", "(", "getDepth", "(", ")", "==", "levelToPrint", ")", "{", "printDotNode", "(", "os", ",", "detail", ",", "treeOptions", ")", ";", "return", ";", "}", "assert", "(", "getDepth", "(", ")", "<", "levelToPrint", ")", ";", "if", "(", "leftChild", "!=", "null", ")", "{", "leftChild", ".", "printDotNodesAtLevel", "(", "os", ",", "levelToPrint", ",", "detail", ",", "treeOptions", ")", ";", "}", "if", "(", "rightChild", "!=", "null", ")", "{", "rightChild", ".", "printDotNodesAtLevel", "(", "os", ",", "levelToPrint", ",", "detail", ",", "treeOptions", ")", ";", "}", "}" ]

[ "Recursively", "print", "nodes", "at", "a", "particular", "depth", "level", "in", "the", "tree", ".", "Useful", "to", "group", "them", "so", "they", "render", "properly", "." ]

[ "public", "void", "init", "(", "Rec", "record", ",", "RemoteTable", "tableRemote", ",", "Object", "syncObject", ")", "{", "super", ".", "init", "(", "record", ")", ";", "this", ".", "setRemoteTable", "(", "tableRemote", ",", "syncObject", ")", ";", "}" ]

[ "Constructor", "." ]

[ "public", "void", "setName", "(", "String", "name", ")", "throws", "ApplicationException", "{", "if", "(", "name", "==", "null", ")", "return", ";", "this", ".", "name", "=", "name", ".", "trim", "(", ")", ";", "if", "(", "name", ".", "length", "(", ")", "==", "0", ")", "throw", "new", "ApplicationException", "(", "\"invalid attribute definition\"", ",", "\"attribute [name] can't be a empty string\"", ")", ";", "}" ]

[ "set", "the", "value", "name" ]

[ "public", "void", "registerCandidate", "(", "Class", "<", "?", ">", "candidateClass", ",", "String", "description", ",", "Candidate", ".", "CandidateType", "type", ")", "{", "Candidate", "candidate", "=", "new", "Candidate", "(", "candidateClass", ",", "description", ",", "type", ")", ";", "int", "index", "=", "candidates", ".", "indexOf", "(", "candidate", ")", ";", "if", "(", "index", ">=", "0", ")", "{", "Candidate", "existingCandidate", "=", "candidates", ".", "get", "(", "index", ")", ";", "if", "(", "!", "description", ".", "equals", "(", "existingCandidate", ".", "getDescription", "(", ")", ")", ")", "{", "throw", "new", "IllegalStateException", "(", "\"Two different descriptions for candidate \"", "+", "candidateClass", ".", "getName", "(", ")", ")", ";", "}", "existingCandidate", ".", "getTypes", "(", ")", ".", "add", "(", "type", ")", ";", "}", "else", "{", "candidates", ".", "add", "(", "candidate", ")", ";", "}", "}" ]

[ "Register", "a", "candidate", "class", "to", "attempt", "to", "instantiate", "." ]

[ "@", "Override", "public", "void", "doRender", "(", "final", "WComponent", "component", ",", "final", "WebXmlRenderContext", "renderContext", ")", "{", "WRadioButton", "button", "=", "(", "WRadioButton", ")", "component", ";", "XmlStringBuilder", "xml", "=", "renderContext", ".", "getWriter", "(", ")", ";", "boolean", "readOnly", "=", "button", ".", "isReadOnly", "(", ")", ";", "String", "value", "=", "button", ".", "getValue", "(", ")", ";", "xml", ".", "appendTagOpen", "(", "\"ui:radiobutton\"", ")", ";", "xml", ".", "appendAttribute", "(", "\"id\"", ",", "component", ".", "getId", "(", ")", ")", ";", "xml", ".", "appendOptionalAttribute", "(", "\"class\"", ",", "component", ".", "getHtmlClass", "(", ")", ")", ";", "xml", ".", "appendOptionalAttribute", "(", "\"track\"", ",", "component", ".", "isTracking", "(", ")", ",", "\"true\"", ")", ";", "xml", ".", "appendOptionalAttribute", "(", "\"hidden\"", ",", "button", ".", "isHidden", "(", ")", ",", "\"true\"", ")", ";", "xml", ".", "appendAttribute", "(", "\"groupName\"", ",", "button", ".", "getGroupName", "(", ")", ")", ";", "xml", ".", "appendAttribute", "(", "\"value\"", ",", "WebUtilities", ".", "encode", "(", "value", ")", ")", ";", "if", "(", "readOnly", ")", "{", "xml", ".", "appendAttribute", "(", "\"readOnly\"", ",", "\"true\"", ")", ";", "}", "else", "{", "xml", ".", "appendOptionalAttribute", "(", "\"disabled\"", ",", "button", ".", "isDisabled", "(", ")", ",", "\"true\"", ")", ";", "xml", ".", "appendOptionalAttribute", "(", "\"required\"", ",", "button", ".", "isMandatory", "(", ")", ",", "\"true\"", ")", ";", "xml", ".", "appendOptionalAttribute", "(", "\"submitOnChange\"", ",", "button", ".", "isSubmitOnChange", "(", ")", ",", "\"true\"", ")", ";", "xml", ".", "appendOptionalAttribute", "(", "\"toolTip\"", ",", "button", ".", "getToolTip", "(", ")", ")", ";", "xml", ".", "appendOptionalAttribute", "(", "\"accessibleText\"", ",", "button", ".", "getAccessibleText", "(", ")", ")", ";", "// Check for null option (ie null or empty). Match isEmpty() logic.", "boolean", "isNull", "=", "value", "==", "null", "?", "true", ":", "(", "value", ".", "length", "(", ")", "==", "0", ")", ";", "xml", ".", "appendOptionalAttribute", "(", "\"isNull\"", ",", "isNull", ",", "\"true\"", ")", ";", "}", "xml", ".", "appendOptionalAttribute", "(", "\"selected\"", ",", "button", ".", "isSelected", "(", ")", ",", "\"true\"", ")", ";", "xml", ".", "appendEnd", "(", ")", ";", "}" ]

[ "Paints", "the", "given", "WRadioButton", "." ]

[ "private", "boolean", "validBooleanExpression", "(", "Node", "expr", ")", "{", "if", "(", "isBooleanOperation", "(", "expr", ")", ")", "{", "return", "validBooleanOperation", "(", "expr", ")", ";", "}", "if", "(", "!", "isOperation", "(", "expr", ")", ")", "{", "warnInvalidExpression", "(", "\"boolean\"", ",", "expr", ")", ";", "return", "false", ";", "}", "if", "(", "!", "isValidPredicate", "(", "getCallName", "(", "expr", ")", ")", ")", "{", "warnInvalid", "(", "\"boolean predicate\"", ",", "expr", ")", ";", "return", "false", ";", "}", "Keywords", "keyword", "=", "nameToKeyword", "(", "getCallName", "(", "expr", ")", ")", ";", "if", "(", "!", "checkParameterCount", "(", "expr", ",", "keyword", ")", ")", "{", "return", "false", ";", "}", "switch", "(", "keyword", ".", "kind", ")", "{", "case", "TYPE_PREDICATE", ":", "return", "validTypePredicate", "(", "expr", ",", "getCallParamCount", "(", "expr", ")", ")", ";", "case", "STRING_PREDICATE", ":", "return", "validStringPredicate", "(", "expr", ",", "getCallParamCount", "(", "expr", ")", ")", ";", "case", "TYPEVAR_PREDICATE", ":", "return", "validTypevarPredicate", "(", "expr", ",", "getCallParamCount", "(", "expr", ")", ")", ";", "default", ":", "throw", "new", "IllegalStateException", "(", "\"Invalid boolean expression\"", ")", ";", "}", "}" ]

[ "A", "boolean", "expression", "must", "be", "a", "boolean", "predicate", "or", "a", "boolean", "type", "predicate" ]

[ "private", "Locale", "getLocale", "(", "CmsResource", "resource", ",", "List", "<", "CmsProperty", ">", "propertyList", ")", "{", "return", "OpenCms", ".", "getLocaleManager", "(", ")", ".", "getDefaultLocale", "(", "m_guestCms", ",", "m_guestCms", ".", "getSitePath", "(", "resource", ")", ")", ";", "}" ]

[ "Gets", "the", "locale", "to", "use", "for", "the", "given", "resource", ".", "<p", ">" ]

[ "public", "static", "Client", "from", "(", "CompositeData", "cd", ")", "{", "Client", "instance", "=", "null", ";", "if", "(", "cd", ".", "containsKey", "(", "\"id\"", ")", ")", "{", "String", "id", "=", "(", "String", ")", "cd", ".", "get", "(", "\"id\"", ")", ";", "instance", "=", "new", "Client", "(", "id", ",", "(", "Long", ")", "cd", ".", "get", "(", "\"creationTime\"", ")", ",", "null", ")", ";", "instance", ".", "setAttribute", "(", "PERMISSIONS", ",", "cd", ".", "get", "(", "PERMISSIONS", ")", ")", ";", "}", "if", "(", "cd", ".", "containsKey", "(", "\"attributes\"", ")", ")", "{", "AttributeStore", "attrs", "=", "(", "AttributeStore", ")", "cd", ".", "get", "(", "\"attributes\"", ")", ";", "instance", ".", "setAttributes", "(", "attrs", ")", ";", "}", "return", "instance", ";", "}" ]

[ "Allows", "for", "reconstruction", "via", "CompositeData", "." ]

[ "public", "static", "<", "T", ">", "Observable", "<", "T", ">", "toColdObservable", "(", "final", "RecursiveFutureProvider", "<", "T", ">", "futureProvider", ")", "{", "return", "Observable", ".", "create", "(", "new", "Observable", ".", "OnSubscribe", "<", "T", ">", "(", ")", "{", "@", "Override", "public", "void", "call", "(", "final", "Subscriber", "<", "?", "super", "T", ">", "subscriber", ")", "{", "recursiveChain", "(", "subscriber", ",", "futureProvider", ".", "createStopCriteria", "(", ")", ")", ";", "}", "private", "void", "recursiveChain", "(", "final", "Subscriber", "<", "?", "super", "T", ">", "subscriber", ",", "final", "Predicate", "<", "T", ">", "stopCriteria", ")", "{", "futureProvider", ".", "provide", "(", ")", ".", "consume", "(", "result", "->", "{", "if", "(", "result", ".", "isSuccess", "(", ")", ")", "{", "final", "T", "value", "=", "result", ".", "getValue", "(", ")", ";", "subscriber", ".", "onNext", "(", "value", ")", ";", "if", "(", "stopCriteria", ".", "apply", "(", "value", ")", ")", "{", "subscriber", ".", "onCompleted", "(", ")", ";", "}", "else", "{", "recursiveChain", "(", "subscriber", ",", "stopCriteria", ")", ";", "}", "}", "else", "{", "subscriber", ".", "onError", "(", "result", ".", "getError", "(", ")", ")", ";", "}", "}", ")", ";", "}", "}", ")", ";", "}" ]

[ "creates", "new", "cold", "observable", "given", "future", "provider", "on", "each", "subscribe", "will", "consume", "the", "provided", "future", "and", "repeat", "until", "stop", "criteria", "will", "exists", "each", "result", "will", "be", "emitted", "to", "the", "stream" ]

[ "public", "boolean", "reserveAllocationIfPossible", "(", "Long", "threadId", ",", "Integer", "deviceId", ",", "long", "memorySize", ")", "{", "ensureThreadRegistered", "(", "threadId", ",", "deviceId", ")", ";", "try", "{", "deviceLocks", ".", "get", "(", "deviceId", ")", ".", "writeLock", "(", ")", ".", "lock", "(", ")", ";", "/*\n if (getAllocatedSize(deviceId) + memorySize + getReservedSpace(deviceId)> environment.getDeviceInformation(deviceId).getTotalMemory() * configuration.getMaxDeviceMemoryUsed()) {\n return false;\n } else {\n addToReservedSpace(deviceId, memorySize);\n return true;\n }\n */", "addToReservedSpace", "(", "deviceId", ",", "memorySize", ")", ";", "return", "true", ";", "}", "finally", "{", "deviceLocks", ".", "get", "(", "deviceId", ")", ".", "writeLock", "(", ")", ".", "unlock", "(", ")", ";", "}", "}" ]

[ "This", "method", "reserves", "memory", "within", "allocator" ]

[ "public", "static", "void", "cursorDoubleToCursorValues", "(", "Cursor", "cursor", ",", "String", "field", ",", "ContentValues", "values", ")", "{", "cursorDoubleToContentValues", "(", "cursor", ",", "field", ",", "values", ",", "field", ")", ";", "}" ]

[ "Reads", "a", "Double", "out", "of", "a", "field", "in", "a", "Cursor", "and", "writes", "it", "to", "a", "Map", "." ]

[ "public", "static", "IpAddress", "createIp6", "(", "String", "value", ",", "String", "admDom", ")", "{", "return", "createIp", "(", "IpAddressType", ".", "IPv6", ",", "value", ",", "admDom", ")", ";", "}" ]

[ "Create", "an", "ip", "-", "address", "identifier", "for", "IPv6", "with", "the", "given", "parameters", "." ]

[ "public", "boolean", "estimateMotion", "(", "Planar", "<", "I", ">", "input", ",", "Se3_F32", "hintKeyToInput", ")", "{", "InputSanityCheck", ".", "checkSameShape", "(", "derivX", ",", "input", ")", ";", "initMotion", "(", "input", ")", ";", "keyToCurrent", ".", "set", "(", "hintKeyToInput", ")", ";", "boolean", "foundSolution", "=", "false", ";", "float", "previousError", "=", "Float", ".", "MAX_VALUE", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "maxIterations", ";", "i", "++", ")", "{", "constructLinearSystem", "(", "input", ",", "keyToCurrent", ")", ";", "if", "(", "!", "solveSystem", "(", ")", ")", "break", ";", "if", "(", "Math", ".", "abs", "(", "previousError", "-", "errorOptical", ")", "/", "previousError", "<", "convergeTol", ")", "break", ";", "else", "{", "// update the estimated motion from the computed twist", "previousError", "=", "errorOptical", ";", "keyToCurrent", ".", "concat", "(", "motionTwist", ",", "tmp", ")", ";", "keyToCurrent", ".", "set", "(", "tmp", ")", ";", "foundSolution", "=", "true", ";", "}", "}", "return", "foundSolution", ";", "}" ]

[ "Estimates", "the", "motion", "relative", "to", "the", "key", "frame", "." ]

[ "public", "static", "Set", "<", "URI", ">", "listInputDocuments", "(", "Options", "options", ")", "throws", "URISyntaxException", ",", "IOException", "{", "URI", "baseUri", "=", "new", "URI", "(", "options", ".", "getInput", "(", ")", ")", ";", "// List all documents in the directory or GCS prefix.", "URI", "absoluteUri", ";", "if", "(", "baseUri", ".", "getScheme", "(", ")", "!=", "null", ")", "{", "absoluteUri", "=", "baseUri", ";", "}", "else", "{", "absoluteUri", "=", "new", "URI", "(", "\"file\"", ",", "baseUri", ".", "getAuthority", "(", ")", ",", "baseUri", ".", "getPath", "(", ")", ",", "baseUri", ".", "getQuery", "(", ")", ",", "baseUri", ".", "getFragment", "(", ")", ")", ";", "}", "Set", "<", "URI", ">", "uris", "=", "new", "HashSet", "<>", "(", ")", ";", "if", "(", "\"file\"", ".", "equals", "(", "absoluteUri", ".", "getScheme", "(", ")", ")", ")", "{", "File", "directory", "=", "new", "File", "(", "absoluteUri", ")", ";", "for", "(", "String", "entry", ":", "Optional", ".", "fromNullable", "(", "directory", ".", "list", "(", ")", ")", ".", "or", "(", "new", "String", "[", "]", "{", "}", ")", ")", "{", "File", "path", "=", "new", "File", "(", "directory", ",", "entry", ")", ";", "uris", ".", "add", "(", "path", ".", "toURI", "(", ")", ")", ";", "}", "}", "else", "if", "(", "\"gs\"", ".", "equals", "(", "absoluteUri", ".", "getScheme", "(", ")", ")", ")", "{", "GcsUtil", "gcsUtil", "=", "options", ".", "as", "(", "GcsOptions", ".", "class", ")", ".", "getGcsUtil", "(", ")", ";", "URI", "gcsUriGlob", "=", "new", "URI", "(", "absoluteUri", ".", "getScheme", "(", ")", ",", "absoluteUri", ".", "getAuthority", "(", ")", ",", "absoluteUri", ".", "getPath", "(", ")", "+", "\"*\"", ",", "absoluteUri", ".", "getQuery", "(", ")", ",", "absoluteUri", ".", "getFragment", "(", ")", ")", ";", "for", "(", "GcsPath", "entry", ":", "gcsUtil", ".", "expand", "(", "GcsPath", ".", "fromUri", "(", "gcsUriGlob", ")", ")", ")", "{", "uris", ".", "add", "(", "entry", ".", "toUri", "(", ")", ")", ";", "}", "}", "return", "uris", ";", "}" ]

[ "Lists", "documents", "contained", "beneath", "the", "{" ]

[ "private", "String", "getValue", "(", "final", "String", "value", ",", "final", "String", "mappedFieldName", ")", "{", "if", "(", "isNull", "(", "value", ")", ")", "return", "null", ";", "return", "value", ".", "equals", "(", "DEFAULT_FIELD_VALUE", ")", "?", "mappedFieldName", ":", "value", ";", "}" ]

[ "This", "method", "compare", "the", "name", "of", "the", "target", "field", "with", "the", "DEFAULT_FIELD_VALUE", "and", "returns", "the", "final", "value", "." ]

[ "public", "static", "File", "getClassFileFromDirectoryInClassPath", "(", "String", "className", ")", "{", "String", "fileName", "=", "StringSupport", ".", "replaceAll", "(", "className", ",", "\".\"", ",", "\"/\"", ")", ";", "fileName", "+=", "\".class\"", ";", "return", "getFileFromDirectoryInClassPath", "(", "fileName", ",", "System", ".", "getProperty", "(", "\"java.class.path\"", ")", ")", ";", "}" ]

[ "Tries", "to", "retrieve", "a", "class", "as", "File", "from", "all", "directories", "mentioned", "in", "system", "property", "java", ".", "class", ".", "path" ]

[ "public", "static", "Date", "addSecond", "(", "String", "date", ",", "int", "amount", ")", "throws", "ParseException", "{", "return", "add", "(", "date", ",", "Calendar", ".", "SECOND", ",", "amount", ")", ";", "}" ]

[ "添加秒" ]

[ "private", "static", "Sort", "first", "(", "String", "columnName", ",", "Sort", ".", "Order", "order", ")", "{", "return", "Sort", ".", "on", "(", "columnName", ",", "order", ")", ";", "}" ]

[ "Returns", "a", "sort", "Key", "that", "can", "be", "used", "for", "simple", "or", "chained", "comparator", "sorting", "<p", ">", "You", "can", "extend", "the", "sort", "key", "by", "using", ".", "next", "()", "to", "fill", "more", "columns", "to", "the", "sort", "order" ]

[ "public", "void", "onLoad", "(", "ItemGroup", "<", "?", "extends", "Item", ">", "parent", ",", "String", "name", ")", "throws", "IOException", "{", "this", ".", "parent", "=", "parent", ";", "doSetName", "(", "name", ")", ";", "}" ]

[ "Called", "right", "after", "when", "a", "{" ]

[ "private", "static", "void", "storeInstallDate", "(", "final", "Context", "context", ",", "SharedPreferences", ".", "Editor", "editor", ")", "{", "Date", "installDate", "=", "new", "Date", "(", ")", ";", "if", "(", "Build", ".", "VERSION", ".", "SDK_INT", ">=", "Build", ".", "VERSION_CODES", ".", "GINGERBREAD", ")", "{", "PackageManager", "packMan", "=", "context", ".", "getPackageManager", "(", ")", ";", "try", "{", "PackageInfo", "pkgInfo", "=", "packMan", ".", "getPackageInfo", "(", "context", ".", "getPackageName", "(", ")", ",", "0", ")", ";", "installDate", "=", "new", "Date", "(", "pkgInfo", ".", "firstInstallTime", ")", ";", "}", "catch", "(", "PackageManager", ".", "NameNotFoundException", "e", ")", "{", "e", ".", "printStackTrace", "(", ")", ";", "}", "}", "editor", ".", "putLong", "(", "KEY_INSTALL_DATE", ",", "installDate", ".", "getTime", "(", ")", ")", ";", "log", "(", "\"First install: \"", "+", "installDate", ".", "toString", "(", ")", ")", ";", "}" ]

[ "Store", "install", "date", ".", "Install", "date", "is", "retrieved", "from", "package", "manager", "if", "possible", "." ]

[ "public", "List", "<", "FormField", ">", "retrieveFormFields", "(", "String", "node", ")", "throws", "NoResponseException", ",", "XMPPErrorException", ",", "NotConnectedException", ",", "InterruptedException", ",", "NotLoggedInException", "{", "String", "queryId", "=", "UUID", ".", "randomUUID", "(", ")", ".", "toString", "(", ")", ";", "MamQueryIQ", "mamQueryIq", "=", "new", "MamQueryIQ", "(", "queryId", ",", "node", ",", "null", ")", ";", "mamQueryIq", ".", "setTo", "(", "archiveAddress", ")", ";", "MamQueryIQ", "mamResponseQueryIq", "=", "connection", "(", ")", ".", "createStanzaCollectorAndSend", "(", "mamQueryIq", ")", ".", "nextResultOrThrow", "(", ")", ";", "return", "mamResponseQueryIq", ".", "getDataForm", "(", ")", ".", "getFields", "(", ")", ";", "}" ]

[ "Get", "the", "form", "fields", "supported", "by", "the", "server", "." ]

[ "public", "void", "writeTo", "(", "ByteBuf", "byteBuf", ",", "Codec", "codec", ")", "{", "writeArray", "(", "byteBuf", ",", "key", ")", ";", "byteBuf", ".", "writeByte", "(", "control", ")", ";", "if", "(", "!", "ControlByte", ".", "NON_EXISTING", ".", "hasFlag", "(", "control", ")", "&&", "!", "ControlByte", ".", "NOT_READ", ".", "hasFlag", "(", "control", ")", ")", "{", "byteBuf", ".", "writeLong", "(", "versionRead", ")", ";", "}", "if", "(", "ControlByte", ".", "REMOVE_OP", ".", "hasFlag", "(", "control", ")", ")", "{", "return", ";", "}", "codec", ".", "writeExpirationParams", "(", "byteBuf", ",", "lifespan", ",", "lifespanTimeUnit", ",", "maxIdle", ",", "maxIdleTimeUnit", ")", ";", "writeArray", "(", "byteBuf", ",", "value", ")", ";", "}" ]

[ "Writes", "this", "modification", "to", "the", "{", "@link", "ByteBuf", "}", "." ]

[ "public", "static", "boolean", "writeString", "(", "String", "inputString", ",", "File", "targetFile", ")", "{", "if", "(", "!", "targetFile", ".", "exists", "(", ")", ")", "{", "try", "{", "Files", ".", "write", "(", "targetFile", ".", "toPath", "(", ")", ",", "inputString", ".", "getBytes", "(", ")", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "return", "JMExceptionManager", ".", "handleExceptionAndReturnFalse", "(", "log", ",", "e", ",", "\"writeString\"", ",", "inputString", ",", "targetFile", ")", ";", "}", "}", "return", "true", ";", "}" ]

[ "Write", "string", "boolean", "." ]

[ "public", "Observable", "<", "PrivateZoneInner", ">", "createOrUpdateAsync", "(", "String", "resourceGroupName", ",", "String", "privateZoneName", ",", "PrivateZoneInner", "parameters", ",", "String", "ifMatch", ",", "String", "ifNoneMatch", ")", "{", "return", "createOrUpdateWithServiceResponseAsync", "(", "resourceGroupName", ",", "privateZoneName", ",", "parameters", ",", "ifMatch", ",", "ifNoneMatch", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "PrivateZoneInner", ">", ",", "PrivateZoneInner", ">", "(", ")", "{", "@", "Override", "public", "PrivateZoneInner", "call", "(", "ServiceResponse", "<", "PrivateZoneInner", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Creates", "or", "updates", "a", "Private", "DNS", "zone", ".", "Does", "not", "modify", "Links", "to", "virtual", "networks", "or", "DNS", "records", "within", "the", "zone", "." ]

[ "protected", "boolean", "executeDot", "(", "Set", "<", "String", ">", "dotFiles", ")", "throws", "MojoExecutionException", "{", "// Build executor for projects base directory", "MavenLogOutputStream", "stdout", "=", "getStdoutStream", "(", ")", ";", "MavenLogOutputStream", "stderr", "=", "getStderrStream", "(", ")", ";", "Executor", "exec", "=", "getExecutor", "(", ")", ";", "exec", ".", "setWorkingDirectory", "(", "project", ".", "getBasedir", "(", ")", ")", ";", "exec", ".", "setStreamHandler", "(", "new", "PumpStreamHandler", "(", "stdout", ",", "stderr", ",", "System", ".", "in", ")", ")", ";", "// Execute commandline and check return code", "try", "{", "int", "exitValue", "=", "exec", ".", "execute", "(", "getDotCommandLine", "(", "dotFiles", ")", ")", ";", "if", "(", "exitValue", "==", "0", "&&", "stdout", ".", "getErrorCount", "(", ")", "==", "0", ")", "{", "return", "true", ";", "}", "}", "catch", "(", "ExecuteException", "e", ")", "{", "// ignore", "}", "catch", "(", "IOException", "e", ")", "{", "// ignore", "}", "return", "false", ";", "}" ]

[ "Executes", "the", "command", "line", "tool", "<code", ">", "dot<", "/", "code", ">", "." ]

[ "public", "static", "List", "<", "RuleInterval", ">", "getZeroIntervals", "(", "int", "[", "]", "coverageArray", ")", "{", "ArrayList", "<", "RuleInterval", ">", "res", "=", "new", "ArrayList", "<", "RuleInterval", ">", "(", ")", ";", "int", "start", "=", "-", "1", ";", "boolean", "inInterval", "=", "false", ";", "int", "intervalsCounter", "=", "-", "1", ";", "// slide over the array from left to the right", "//", "for", "(", "int", "i", "=", "0", ";", "i", "<", "coverageArray", ".", "length", ";", "i", "++", ")", "{", "if", "(", "0", "==", "coverageArray", "[", "i", "]", "&&", "!", "inInterval", ")", "{", "start", "=", "i", ";", "inInterval", "=", "true", ";", "}", "if", "(", "coverageArray", "[", "i", "]", ">", "0", "&&", "inInterval", ")", "{", "res", ".", "add", "(", "new", "RuleInterval", "(", "intervalsCounter", ",", "start", ",", "i", ",", "0", ")", ")", ";", "inInterval", "=", "false", ";", "intervalsCounter", "--", ";", "}", "}", "// we need to check for the last interval here", "//", "if", "(", "inInterval", ")", "{", "res", ".", "add", "(", "new", "RuleInterval", "(", "intervalsCounter", ",", "start", ",", "coverageArray", ".", "length", ",", "0", ")", ")", ";", "}", "return", "res", ";", "}" ]

[ "Run", "a", "quick", "scan", "along", "the", "time", "series", "coverage", "to", "find", "a", "zeroed", "intervals", "." ]

[ "private", "Collection", "<", "FsItemEx", ">", "findRecursively", "(", "FsItemFilter", "filter", ",", "FsItem", "root", ")", "{", "List", "<", "FsItemEx", ">", "results", "=", "new", "ArrayList", "<", "FsItemEx", ">", "(", ")", ";", "FsVolume", "vol", "=", "root", ".", "getVolume", "(", ")", ";", "for", "(", "FsItem", "child", ":", "vol", ".", "listChildren", "(", "root", ")", ")", "{", "if", "(", "vol", ".", "isFolder", "(", "child", ")", ")", "{", "results", ".", "addAll", "(", "findRecursively", "(", "filter", ",", "child", ")", ")", ";", "}", "else", "{", "FsItemEx", "item", "=", "new", "FsItemEx", "(", "child", ",", "this", ")", ";", "if", "(", "filter", ".", "accepts", "(", "item", ")", ")", "results", ".", "add", "(", "item", ")", ";", "}", "}", "return", "results", ";", "}" ]

[ "find", "files", "recursively", "in", "specific", "folder" ]

[ "public", "void", "setData", "(", "String", "key", ",", "Object", "value", ")", "{", "this", ".", "data", "=", "this", ".", "data", ".", "addData", "(", "key", ",", "value", ")", ";", "}" ]

[ "Stores", "a", "key", "-", "value", "data", "in", "the", "context", "." ]

[ "private", "IndexTreePath", "<", "E", ">", "choosePath", "(", "AbstractMTree", "<", "?", ",", "N", ",", "E", ",", "?", ">", "tree", ",", "E", "object", ",", "IndexTreePath", "<", "E", ">", "subtree", ")", "{", "N", "node", "=", "tree", ".", "getNode", "(", "subtree", ".", "getEntry", "(", ")", ")", ";", "// leaf", "if", "(", "node", ".", "isLeaf", "(", ")", ")", "{", "return", "subtree", ";", "}", "// Initialize from first:", "int", "bestIdx", "=", "0", ";", "E", "bestEntry", "=", "node", ".", "getEntry", "(", "0", ")", ";", "double", "bestDistance", "=", "tree", ".", "distance", "(", "object", ".", "getRoutingObjectID", "(", ")", ",", "bestEntry", ".", "getRoutingObjectID", "(", ")", ")", ";", "// Iterate over remaining", "for", "(", "int", "i", "=", "1", ";", "i", "<", "node", ".", "getNumEntries", "(", ")", ";", "i", "++", ")", "{", "E", "entry", "=", "node", ".", "getEntry", "(", "i", ")", ";", "double", "distance", "=", "tree", ".", "distance", "(", "object", ".", "getRoutingObjectID", "(", ")", ",", "entry", ".", "getRoutingObjectID", "(", ")", ")", ";", "if", "(", "distance", "<", "bestDistance", ")", "{", "bestIdx", "=", "i", ";", "bestEntry", "=", "entry", ";", "bestDistance", "=", "distance", ";", "}", "}", "return", "choosePath", "(", "tree", ",", "object", ",", "new", "IndexTreePath", "<>", "(", "subtree", ",", "bestEntry", ",", "bestIdx", ")", ")", ";", "}" ]

[ "Chooses", "the", "best", "path", "of", "the", "specified", "subtree", "for", "insertion", "of", "the", "given", "object", "." ]

[ "private", "void", "formatAndLog", "(", "int", "level", ",", "String", "format", ",", "Object", "arg1", ",", "Object", "arg2", ")", "{", "if", "(", "!", "isLevelEnabled", "(", "level", ")", ")", "{", "return", ";", "}", "FormattingTuple", "tp", "=", "MessageFormatter", ".", "format", "(", "format", ",", "arg1", ",", "arg2", ")", ";", "log", "(", "level", ",", "tp", ".", "getMessage", "(", ")", ",", "tp", ".", "getThrowable", "(", ")", ")", ";", "}" ]

[ "For", "formatted", "messages", "first", "substitute", "arguments", "and", "then", "log", "." ]

[ "public", "static", "double", "kendallsTau", "(", "double", "[", "]", "a", ",", "double", "[", "]", "b", ")", "{", "return", "kendallsTau", "(", "Vectors", ".", "asVector", "(", "a", ")", ",", "Vectors", ".", "asVector", "(", "b", ")", ")", ";", "}" ]

[ "Computes", "<a", "href", "=", "http", ":", "//", "en", ".", "wikipedia", ".", "org", "/", "wiki", "/", "Kendall%27s_tau", ">", "Kendall", "s", "tau<", "/", "a", ">", "of", "the", "values", "in", "the", "two", "arrays", ".", "This", "method", "uses", "tau", "-", "b", "which", "is", "suitable", "for", "arrays", "with", "duplicate", "values", "." ]

[ "@", "NonNull", "public", "Parameters", "setDate", "(", "@", "NonNull", "String", "name", ",", "Date", "value", ")", "{", "return", "setValue", "(", "name", ",", "value", ")", ";", "}" ]

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

[ "public", "void", "processPacketAESCM", "(", "RawPacket", "pkt", ",", "int", "index", ")", "{", "long", "ssrc", "=", "pkt", ".", "getRTCPSSRC", "(", ")", ";", "/* Compute the CM IV (refer to chapter 4.1.1 in RFC 3711):\r\n *\r\n * k_s XX XX XX XX XX XX XX XX XX XX XX XX XX XX\r\n * SSRC XX XX XX XX\r\n * index XX XX XX XX\r\n * ------------------------------------------------------XOR\r\n * IV XX XX XX XX XX XX XX XX XX XX XX XX XX XX 00 00\r\n * 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15\r\n */", "ivStore", "[", "0", "]", "=", "saltKey", "[", "0", "]", ";", "ivStore", "[", "1", "]", "=", "saltKey", "[", "1", "]", ";", "ivStore", "[", "2", "]", "=", "saltKey", "[", "2", "]", ";", "ivStore", "[", "3", "]", "=", "saltKey", "[", "3", "]", ";", "// The shifts transform the ssrc and index into network order\r", "ivStore", "[", "4", "]", "=", "(", "byte", ")", "(", "(", "(", "ssrc", ">>", "24", ")", "&", "0xff", ")", "^", "this", ".", "saltKey", "[", "4", "]", ")", ";", "ivStore", "[", "5", "]", "=", "(", "byte", ")", "(", "(", "(", "ssrc", ">>", "16", ")", "&", "0xff", ")", "^", "this", ".", "saltKey", "[", "5", "]", ")", ";", "ivStore", "[", "6", "]", "=", "(", "byte", ")", "(", "(", "(", "ssrc", ">>", "8", ")", "&", "0xff", ")", "^", "this", ".", "saltKey", "[", "6", "]", ")", ";", "ivStore", "[", "7", "]", "=", "(", "byte", ")", "(", "(", "ssrc", "&", "0xff", ")", "^", "this", ".", "saltKey", "[", "7", "]", ")", ";", "ivStore", "[", "8", "]", "=", "saltKey", "[", "8", "]", ";", "ivStore", "[", "9", "]", "=", "saltKey", "[", "9", "]", ";", "ivStore", "[", "10", "]", "=", "(", "byte", ")", "(", "(", "(", "index", ">>", "24", ")", "&", "0xff", ")", "^", "this", ".", "saltKey", "[", "10", "]", ")", ";", "ivStore", "[", "11", "]", "=", "(", "byte", ")", "(", "(", "(", "index", ">>", "16", ")", "&", "0xff", ")", "^", "this", ".", "saltKey", "[", "11", "]", ")", ";", "ivStore", "[", "12", "]", "=", "(", "byte", ")", "(", "(", "(", "index", ">>", "8", ")", "&", "0xff", ")", "^", "this", ".", "saltKey", "[", "12", "]", ")", ";", "ivStore", "[", "13", "]", "=", "(", "byte", ")", "(", "(", "index", "&", "0xff", ")", "^", "this", ".", "saltKey", "[", "13", "]", ")", ";", "ivStore", "[", "14", "]", "=", "ivStore", "[", "15", "]", "=", "0", ";", "// Encrypted part excludes fixed header (8 bytes) \r", "final", "int", "payloadOffset", "=", "8", ";", "final", "int", "payloadLength", "=", "pkt", ".", "getLength", "(", ")", "-", "payloadOffset", ";", "cipherCtr", ".", "process", "(", "cipher", ",", "pkt", ".", "getBuffer", "(", ")", ",", "payloadOffset", ",", "payloadLength", ",", "ivStore", ")", ";", "}" ]

[ "Perform", "Counter", "Mode", "AES", "encryption", "/", "decryption" ]

[ "boolean", "processOldJdk", "(", "String", "jdkHome", ",", "Collection", "<", "String", ">", "classNames", ")", "throws", "IOException", "{", "String", "RTJAR", "=", "jdkHome", "+", "\"/jre/lib/rt.jar\"", ";", "String", "CSJAR", "=", "jdkHome", "+", "\"/jre/lib/charsets.jar\"", ";", "bootClassPath", ".", "add", "(", "0", ",", "new", "File", "(", "RTJAR", ")", ")", ";", "bootClassPath", ".", "add", "(", "1", ",", "new", "File", "(", "CSJAR", ")", ")", ";", "options", ".", "add", "(", "\"-source\"", ")", ";", "options", ".", "add", "(", "\"8\"", ")", ";", "if", "(", "classNames", ".", "isEmpty", "(", ")", ")", "{", "return", "doJarFile", "(", "RTJAR", ")", ";", "}", "else", "{", "return", "doClassNames", "(", "classNames", ")", ";", "}", "}" ]

[ "Processes", "named", "class", "files", "from", "rt", ".", "jar", "of", "a", "JDK", "version", "7", "or", "8", ".", "If", "classNames", "is", "empty", "processes", "all", "classes", "." ]

[ "public", "static", "void", "checkAssignability", "(", "Class", "<", "?", ">", "c1", ",", "Class", "<", "?", ">", "c2", ")", "{", "COMPARISON_TYPE", "ct1", "=", "COMPARISON_TYPE", ".", "fromClass", "(", "c1", ")", ";", "COMPARISON_TYPE", "ct2", "=", "COMPARISON_TYPE", ".", "fromClass", "(", "c2", ")", ";", "try", "{", "COMPARISON_TYPE", ".", "fromOperands", "(", "ct1", ",", "ct2", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "DBLogger", ".", "newUser", "(", "\"Cannot assign \"", "+", "c2", "+", "\" to \"", "+", "c1", ",", "e", ")", ";", "}", "}" ]

[ "This", "assumes", "that", "comparability", "implies", "assignability", "or", "convertability", "..." ]

[ "public", "void", "exportData", "(", "CmsObject", "cms", ",", "I_CmsImportExportHandler", "handler", ",", "I_CmsReport", "report", ")", "throws", "CmsConfigurationException", ",", "CmsImportExportException", ",", "CmsRoleViolationException", "{", "OpenCms", ".", "getRoleManager", "(", ")", ".", "checkRole", "(", "cms", ",", "CmsRole", ".", "DATABASE_MANAGER", ")", ";", "handler", ".", "exportData", "(", "cms", ",", "report", ")", ";", "}" ]

[ "Checks", "if", "the", "current", "user", "has", "permissions", "to", "export", "Cms", "data", "of", "a", "specified", "export", "handler", "and", "if", "so", "triggers", "the", "handler", "to", "write", "the", "export", ".", "<p", ">" ]

[ "public", "static", "long", "traceEnterWithContext", "(", "Logger", "log", ",", "String", "context", ",", "String", "method", ",", "Object", "...", "args", ")", "{", "if", "(", "!", "log", ".", "isTraceEnabled", "(", ")", ")", "{", "return", "0", ";", "}", "long", "time", "=", "CURRENT_TIME", ".", "get", "(", ")", ";", "log", ".", "trace", "(", "\"ENTER {}::{}@{} {}.\"", ",", "context", ",", "method", ",", "time", ",", "args", ")", ";", "return", "time", ";", "}" ]

[ "Traces", "the", "fact", "that", "a", "method", "entry", "has", "occurred", "." ]

[ "public", "void", "switchOn", "(", "BitSet", "switchGroupAddress", ",", "int", "switchCode", ")", "{", "if", "(", "switchGroupAddress", ".", "length", "(", ")", ">", "5", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"switch group address has more than 5 bits!\"", ")", ";", "}", "this", ".", "sendTriState", "(", "this", ".", "getCodeWordA", "(", "switchGroupAddress", ",", "switchCode", ",", "true", ")", ")", ";", "}" ]

[ "Switch", "a", "remote", "switch", "on", "(", "Type", "A", "with", "10", "pole", "DIP", "switches", ")" ]

[ "public", "OvhOrder", "hosting_privateDatabase_serviceName_ram_duration_GET", "(", "String", "serviceName", ",", "String", "duration", ",", "OvhAvailableRamSizeEnum", "ram", ")", "throws", "IOException", "{", "String", "qPath", "=", "\"/order/hosting/privateDatabase/{serviceName}/ram/{duration}\"", ";", "StringBuilder", "sb", "=", "path", "(", "qPath", ",", "serviceName", ",", "duration", ")", ";", "query", "(", "sb", ",", "\"ram\"", ",", "ram", ")", ";", "String", "resp", "=", "exec", "(", "qPath", ",", "\"GET\"", ",", "sb", ".", "toString", "(", ")", ",", "null", ")", ";", "return", "convertTo", "(", "resp", ",", "OvhOrder", ".", "class", ")", ";", "}" ]

[ "Get", "prices", "and", "contracts", "information" ]

[ "public", "static", "void", "startServices", "(", "IServiceManager", "manager", ")", "{", "final", "List", "<", "Service", ">", "otherServices", "=", "new", "ArrayList", "<>", "(", ")", ";", "final", "List", "<", "Service", ">", "infraServices", "=", "new", "ArrayList", "<>", "(", ")", ";", "final", "LinkedList", "<", "DependencyNode", ">", "serviceQueue", "=", "new", "LinkedList", "<>", "(", ")", ";", "final", "Accessors", "accessors", "=", "new", "StartingPhaseAccessors", "(", ")", ";", "// Build the dependency graph", "buildDependencyGraph", "(", "manager", ",", "serviceQueue", ",", "infraServices", ",", "otherServices", ",", "accessors", ")", ";", "// Launch the services", "runDependencyGraph", "(", "serviceQueue", ",", "infraServices", ",", "otherServices", ",", "accessors", ")", ";", "manager", ".", "awaitHealthy", "(", ")", ";", "}" ]

[ "Start", "the", "services", "associated", "to", "the", "given", "service", "manager", "." ]

[ "public", "static", "<", "T", ">", "void", "writeTo", "(", "OutputStream", "out", ",", "T", "message", ",", "Schema", "<", "T", ">", "schema", ")", "throws", "IOException", "{", "writeTo", "(", "out", ",", "message", ",", "schema", ",", "DEFAULT_OUTPUT_FACTORY", ")", ";", "}" ]

[ "Serializes", "the", "{" ]

[ "public", "void", "onClick", "(", "View", "targetView", ",", "BaseCell", "cell", ",", "int", "eventType", ")", "{", "if", "(", "cell", "instanceof", "Cell", ")", "{", "onClick", "(", "targetView", ",", "(", "Cell", ")", "cell", ",", "eventType", ")", ";", "}", "else", "{", "onClick", "(", "targetView", ",", "cell", ",", "eventType", ",", "null", ")", ";", "}", "}" ]

[ "Handler", "click", "event", "on", "item" ]

[ "public", "static", "Document", "toDocument", "(", "final", "String", "aFilePath", ",", "final", "String", "aPattern", ")", "throws", "FileNotFoundException", ",", "ParserConfigurationException", "{", "return", "toDocument", "(", "aFilePath", ",", "aPattern", ",", "false", ")", ";", "}" ]

[ "Returns", "an", "XML", "Document", "representing", "the", "file", "structure", "found", "at", "the", "supplied", "file", "system", "path", ".", "Files", "included", "in", "the", "representation", "will", "match", "the", "supplied", "regular", "expression", "pattern", ".", "This", "method", "doesn", "t", "descend", "through", "the", "directory", "structure", "." ]

[ "@", "NonNull", "public", "static", "Typeface", "obtainTypeface", "(", "@", "NonNull", "Context", "context", ",", "@", "RobotoTypeface", "int", "typefaceValue", ")", "{", "Typeface", "typeface", "=", "typefacesCache", ".", "get", "(", "typefaceValue", ")", ";", "if", "(", "typeface", "==", "null", ")", "{", "typeface", "=", "createTypeface", "(", "context", ",", "typefaceValue", ")", ";", "typefacesCache", ".", "put", "(", "typefaceValue", ",", "typeface", ")", ";", "}", "return", "typeface", ";", "}" ]

[ "Obtain", "typeface", "." ]

[ "public", "static", "NFCompressedGraph", "readFrom", "(", "InputStream", "is", ",", "ByteSegmentPool", "memoryPool", ")", "throws", "IOException", "{", "NFCompressedGraphDeserializer", "deserializer", "=", "new", "NFCompressedGraphDeserializer", "(", ")", ";", "return", "deserializer", ".", "deserialize", "(", "is", ",", "memoryPool", ")", ";", "}" ]

[ "When", "using", "a", "{" ]

[ "private", "void", "putDataPoint", "(", "int", "i", ",", "Entry", "<", "Long", ",", "Double", ">", "datapoint", ")", "{", "timestamps", "[", "i", "]", "=", "datapoint", ".", "getKey", "(", ")", ";", "values", "[", "i", "]", "=", "datapoint", ".", "getValue", "(", ")", ";", "}" ]

[ "Puts", "the", "next", "data", "point", "of", "an", "iterator", "in", "the", "next", "section", "of", "internal", "buffer", "." ]

[ "public", "static", "boolean", "checkName", "(", "String", "nameSpec", ",", "String", "identifier", ",", "LombokNode", "<", "?", ",", "?", ",", "?", ">", "errorNode", ")", "{", "if", "(", "identifier", ".", "isEmpty", "(", ")", ")", "{", "errorNode", ".", "addError", "(", "nameSpec", "+", "\" cannot be the empty string.\"", ")", ";", "return", "false", ";", "}", "if", "(", "!", "JavaIdentifiers", ".", "isValidJavaIdentifier", "(", "identifier", ")", ")", "{", "errorNode", ".", "addError", "(", "nameSpec", "+", "\" must be a valid java identifier.\"", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Checks", "if", "the", "given", "name", "is", "a", "valid", "identifier", "." ]

[ "public", "void", "startDTD", "(", "String", "name", ",", "String", "publicId", ",", "String", "systemId", ")", "throws", "SAXException", "{", "m_handler", ".", "startDTD", "(", "name", ",", "publicId", ",", "systemId", ")", ";", "}" ]

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

[ "public", "static", "MozuUrl", "getSegmentUrl", "(", "Integer", "id", ",", "String", "responseFields", ")", "{", "UrlFormatter", "formatter", "=", "new", "UrlFormatter", "(", "\"/api/commerce/customer/segments/{id}?responseFields={responseFields}\"", ")", ";", "formatter", ".", "formatUrl", "(", "\"id\"", ",", "id", ")", ";", "formatter", ".", "formatUrl", "(", "\"responseFields\"", ",", "responseFields", ")", ";", "return", "new", "MozuUrl", "(", "formatter", ".", "getResourceUrl", "(", ")", ",", "MozuUrl", ".", "UrlLocation", ".", "TENANT_POD", ")", ";", "}" ]

[ "Get", "Resource", "Url", "for", "GetSegment" ]

[ "private", "boolean", "shouldSkipExpressionProcessing", "(", "String", "expressionString", ")", "{", "// We don't skip if it's a component prop as we want Java validation", "// We don't optimize String expression, as we want GWT to convert Java values", "// to String for us (Enums, wrapped primitives...)", "return", "currentProp", "==", "null", "&&", "!", "String", ".", "class", ".", "getCanonicalName", "(", ")", ".", "equals", "(", "currentExpressionReturnType", ".", "toString", "(", ")", ")", "&&", "isSimpleVueJsExpression", "(", "expressionString", ")", ";", "}" ]

[ "In", "some", "cases", "we", "want", "to", "skip", "expression", "processing", "for", "optimization", ".", "This", "is", "when", "we", "are", "sure", "the", "expression", "is", "valid", "and", "there", "is", "no", "need", "to", "create", "a", "Java", "method", "for", "it", "." ]

[ "@", "SuppressWarnings", "(", "\"PMD.AvoidInstantiatingObjectsInLoops\"", ")", "private", "static", "Iterable", "<", "String", ">", "extend", "(", "final", "Response", "res", ",", "final", "Iterable", "<", "?", "extends", "CharSequence", ">", "headers", ")", "throws", "IOException", "{", "Response", "resp", "=", "res", ";", "for", "(", "final", "CharSequence", "hdr", ":", "headers", ")", "{", "resp", "=", "new", "RsWithHeader", "(", "resp", ",", "hdr", ")", ";", "}", "return", "resp", ".", "head", "(", ")", ";", "}" ]

[ "Add", "to", "head", "additional", "headers", "." ]

[ "public", "Observable", "<", "ApplicationInsightsComponentInner", ">", "getByResourceGroupAsync", "(", "String", "resourceGroupName", ",", "String", "resourceName", ")", "{", "return", "getByResourceGroupWithServiceResponseAsync", "(", "resourceGroupName", ",", "resourceName", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "ApplicationInsightsComponentInner", ">", ",", "ApplicationInsightsComponentInner", ">", "(", ")", "{", "@", "Override", "public", "ApplicationInsightsComponentInner", "call", "(", "ServiceResponse", "<", "ApplicationInsightsComponentInner", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Returns", "an", "Application", "Insights", "component", "." ]

[ "public", "static", "FunctionImport", "getAndCheckFunctionImport", "(", "EntityDataModel", "entityDataModel", ",", "String", "functionImportName", ")", "{", "FunctionImport", "functionImport", "=", "entityDataModel", ".", "getEntityContainer", "(", ")", ".", "getFunctionImport", "(", "functionImportName", ")", ";", "if", "(", "functionImport", "==", "null", ")", "{", "throw", "new", "ODataSystemException", "(", "\"Function import not found in the entity data model: \"", "+", "functionImportName", ")", ";", "}", "return", "functionImport", ";", "}" ]

[ "Gets", "the", "function", "import", "by", "the", "specified", "name", "throw", "an", "exception", "if", "no", "function", "import", "with", "the", "specified", "name", "exists", "." ]

[ "public", "void", "sendAndReceive", "(", "HttpMessage", "message", ",", "HttpRequestConfig", "requestConfig", ")", "throws", "IOException", "{", "if", "(", "message", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Parameter message must not be null.\"", ")", ";", "}", "if", "(", "requestConfig", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Parameter requestConfig must not be null.\"", ")", ";", "}", "sendAndReceiveImpl", "(", "message", ",", "requestConfig", ")", ";", "if", "(", "requestConfig", ".", "isFollowRedirects", "(", ")", ")", "{", "followRedirections", "(", "message", ",", "requestConfig", ")", ";", "}", "}" ]

[ "Sends", "the", "request", "of", "given", "HTTP", "{", "@code", "message", "}", "with", "the", "given", "configurations", "." ]

[ "public", "static", "void", "generateSessionIdIfNecessary", "(", "final", "TraceeBackend", "backend", ",", "final", "String", "sessionId", ")", "{", "if", "(", "backend", "!=", "null", "&&", "!", "backend", ".", "containsKey", "(", "TraceeConstants", ".", "SESSION_ID_KEY", ")", "&&", "backend", ".", "getConfiguration", "(", ")", ".", "shouldGenerateSessionId", "(", ")", ")", "{", "backend", ".", "put", "(", "TraceeConstants", ".", "SESSION_ID_KEY", ",", "Utilities", ".", "createAlphanumericHash", "(", "sessionId", ",", "backend", ".", "getConfiguration", "(", ")", ".", "generatedSessionIdLength", "(", ")", ")", ")", ";", "}", "}" ]

[ "Generate", "session", "id", "hash", "if", "it", "doesn", "t", "exist", "in", "TraceeBackend", "and", "configuration", "asks", "for", "one" ]

[ "private", "INode", "getErrorNode", "(", "XExpression", "expression", ",", "INode", "node", ")", "{", "if", "(", "expression", "instanceof", "XFeatureCall", ")", "{", "XFeatureCall", "featureCall", "=", "(", "XFeatureCall", ")", "expression", ";", "if", "(", "!", "canBeTypeLiteral", "(", "featureCall", ")", ")", "{", "return", "node", ";", "}", "if", "(", "featureCall", ".", "eContainingFeature", "(", ")", "==", "XbasePackage", ".", "Literals", ".", "XMEMBER_FEATURE_CALL__MEMBER_CALL_TARGET", ")", "{", "XMemberFeatureCall", "container", "=", "(", "XMemberFeatureCall", ")", "featureCall", ".", "eContainer", "(", ")", ";", "if", "(", "canBeTypeLiteral", "(", "container", ")", ")", "{", "boolean", "explicitStatic", "=", "container", ".", "isExplicitStatic", "(", ")", ";", "XMemberFeatureCall", "outerMost", "=", "getLongestTypeLiteralCandidate", "(", "container", ",", "explicitStatic", ")", ";", "if", "(", "outerMost", "!=", "null", ")", "return", "NodeModelUtils", ".", "getNode", "(", "outerMost", ")", ";", "}", "}", "}", "return", "node", ";", "}" ]

[ "Returns", "the", "node", "that", "best", "describes", "the", "error", "e", ".", "g", ".", "if", "there", "is", "an", "expression", "<code", ">", "com", "::", "foo", "::", "DoesNotExist", "::", "method", "()", "<", "/", "code", ">", "the", "error", "will", "be", "rooted", "at", "<code", ">", "com<", "/", "code", ">", "but", "the", "real", "problem", "is", "<code", ">", "com", "::", "foo", "::", "DoesNotExist<", "/", "code", ">", "." ]

[ "private", "void", "doPaintRows", "(", "final", "WDataTable", "table", ",", "final", "WebXmlRenderContext", "renderContext", ")", "{", "TableDataModel", "model", "=", "table", ".", "getDataModel", "(", ")", ";", "WRepeater", "repeater", "=", "table", ".", "getRepeater", "(", ")", ";", "List", "<", "?", ">", "beanList", "=", "repeater", ".", "getBeanList", "(", ")", ";", "final", "int", "rowCount", "=", "beanList", ".", "size", "(", ")", ";", "WComponent", "row", "=", "repeater", ".", "getRepeatedComponent", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "rowCount", ";", "i", "++", ")", "{", "if", "(", "model", "instanceof", "TreeTableDataModel", ")", "{", "Integer", "nodeIdx", "=", "(", "Integer", ")", "beanList", ".", "get", "(", "i", ")", ";", "TableTreeNode", "node", "=", "(", "(", "TreeTableDataModel", ")", "model", ")", ".", "getNodeAtLine", "(", "nodeIdx", ")", ";", "if", "(", "node", ".", "getLevel", "(", ")", "!=", "1", ")", "{", "// Handled by the layout, so don't paint the row.", "continue", ";", "}", "}", "// Each row has its own context. This is why we can reuse the same", "// WComponent instance for each row.", "UIContext", "rowContext", "=", "repeater", ".", "getRowContext", "(", "beanList", ".", "get", "(", "i", ")", ",", "i", ")", ";", "UIContextHolder", ".", "pushContext", "(", "rowContext", ")", ";", "try", "{", "row", ".", "paint", "(", "renderContext", ")", ";", "}", "finally", "{", "UIContextHolder", ".", "popContext", "(", ")", ";", "}", "}", "}" ]

[ "Override", "paintRow", "so", "that", "we", "only", "paint", "the", "first", "-", "level", "nodes", "for", "tree", "-", "tables", "." ]

[ "public", "static", "LocalCall", "<", "String", ">", "getHash", "(", "String", "path", ")", "{", "return", "getHash", "(", "path", ",", "Optional", ".", "empty", "(", ")", ",", "Optional", ".", "empty", "(", ")", ")", ";", "}" ]

[ "Get", "the", "hash", "sum", "of", "a", "file", "<p", ">", "SHA256", "algorithm", "is", "used", "by", "default" ]

[ "public", "Point2d", "toScreenCoordinates", "(", "double", "modelX", ",", "double", "modelY", ")", "{", "double", "[", "]", "dest", "=", "new", "double", "[", "2", "]", ";", "transform", ".", "transform", "(", "new", "double", "[", "]", "{", "modelX", ",", "modelY", "}", ",", "0", ",", "dest", ",", "0", ",", "1", ")", ";", "return", "new", "Point2d", "(", "dest", "[", "0", "]", ",", "dest", "[", "1", "]", ")", ";", "}" ]

[ "Convert", "a", "point", "in", "model", "space", "into", "a", "point", "in", "screen", "space", "." ]

[ "public", "void", "setDatePicker", "(", "int", "index", ",", "int", "year", ",", "int", "monthOfYear", ",", "int", "dayOfMonth", ")", "{", "if", "(", "config", ".", "commandLogging", ")", "{", "Log", ".", "d", "(", "config", ".", "commandLoggingTag", ",", "\"setDatePicker(\"", "+", "index", "+", "\", \"", "+", "year", "+", "\", \"", "+", "monthOfYear", "+", "\", \"", "+", "dayOfMonth", "+", "\")\"", ")", ";", "}", "setDatePicker", "(", "waiter", ".", "waitForAndGetView", "(", "index", ",", "DatePicker", ".", "class", ")", ",", "year", ",", "monthOfYear", ",", "dayOfMonth", ")", ";", "}" ]

[ "Sets", "the", "date", "in", "a", "DatePicker", "matching", "the", "specified", "index", "." ]

[ "protected", "String", "findInSourceFolders", "(", "File", "baseDir", ",", "String", "fileName", ")", "{", "String", "answer", "=", "findInFolder", "(", "baseDir", ",", "fileName", ")", ";", "if", "(", "answer", "==", "null", "&&", "baseDir", ".", "exists", "(", ")", ")", "{", "answer", "=", "findInChildFolders", "(", "new", "File", "(", "baseDir", ",", "\"src/main\"", ")", ",", "fileName", ")", ";", "if", "(", "answer", "==", "null", ")", "{", "answer", "=", "findInChildFolders", "(", "new", "File", "(", "baseDir", ",", "\"src/test\"", ")", ",", "fileName", ")", ";", "}", "}", "return", "answer", ";", "}" ]

[ "Searches", "in", "this", "directory", "and", "in", "the", "source", "directories", "in", "src", "/", "main", "/", "*", "and", "src", "/", "test", "/", "*", "for", "the", "given", "file", "name", "path" ]

[ "@", "Override", "public", "int", "countByLtD_S", "(", "Date", "displayDate", ",", "int", "status", ")", "{", "FinderPath", "finderPath", "=", "FINDER_PATH_WITH_PAGINATION_COUNT_BY_LTD_S", ";", "Object", "[", "]", "finderArgs", "=", "new", "Object", "[", "]", "{", "_getTime", "(", "displayDate", ")", ",", "status", "}", ";", "Long", "count", "=", "(", "Long", ")", "finderCache", ".", "getResult", "(", "finderPath", ",", "finderArgs", ",", "this", ")", ";", "if", "(", "count", "==", "null", ")", "{", "StringBundler", "query", "=", "new", "StringBundler", "(", "3", ")", ";", "query", ".", "append", "(", "_SQL_COUNT_CPINSTANCE_WHERE", ")", ";", "boolean", "bindDisplayDate", "=", "false", ";", "if", "(", "displayDate", "==", "null", ")", "{", "query", ".", "append", "(", "_FINDER_COLUMN_LTD_S_DISPLAYDATE_1", ")", ";", "}", "else", "{", "bindDisplayDate", "=", "true", ";", "query", ".", "append", "(", "_FINDER_COLUMN_LTD_S_DISPLAYDATE_2", ")", ";", "}", "query", ".", "append", "(", "_FINDER_COLUMN_LTD_S_STATUS_2", ")", ";", "String", "sql", "=", "query", ".", "toString", "(", ")", ";", "Session", "session", "=", "null", ";", "try", "{", "session", "=", "openSession", "(", ")", ";", "Query", "q", "=", "session", ".", "createQuery", "(", "sql", ")", ";", "QueryPos", "qPos", "=", "QueryPos", ".", "getInstance", "(", "q", ")", ";", "if", "(", "bindDisplayDate", ")", "{", "qPos", ".", "add", "(", "new", "Timestamp", "(", "displayDate", ".", "getTime", "(", ")", ")", ")", ";", "}", "qPos", ".", "add", "(", "status", ")", ";", "count", "=", "(", "Long", ")", "q", ".", "uniqueResult", "(", ")", ";", "finderCache", ".", "putResult", "(", "finderPath", ",", "finderArgs", ",", "count", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "finderCache", ".", "removeResult", "(", "finderPath", ",", "finderArgs", ")", ";", "throw", "processException", "(", "e", ")", ";", "}", "finally", "{", "closeSession", "(", "session", ")", ";", "}", "}", "return", "count", ".", "intValue", "(", ")", ";", "}" ]

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

[ "public", "static", "Execed", "appAs", "(", "String", "as", ",", "String", "...", "command", ")", "throws", "IOException", "{", "return", "appAs", "(", "as", ",", "Arrays", ".", "asList", "(", "command", ")", ")", ";", "}" ]

[ "Runs", "a", "command", "optionally", "executing", "as", "a", "different", "user", "(", "eg", "root", ")" ]

[ "private", "static", "void", "qualifiedNameFix", "(", "final", "SuggestedFix", ".", "Builder", "fix", ",", "final", "Symbol", "owner", ",", "VisitorState", "state", ")", "{", "fix", ".", "addImport", "(", "owner", ".", "getQualifiedName", "(", ")", ".", "toString", "(", ")", ")", ";", "final", "JCCompilationUnit", "unit", "=", "(", "JCCompilationUnit", ")", "state", ".", "getPath", "(", ")", ".", "getCompilationUnit", "(", ")", ";", "new", "TreePathScanner", "<", "Void", ",", "Void", ">", "(", ")", "{", "@", "Override", "public", "Void", "visitIdentifier", "(", "IdentifierTree", "tree", ",", "Void", "unused", ")", "{", "Symbol", "sym", "=", "ASTHelpers", ".", "getSymbol", "(", "tree", ")", ";", "if", "(", "sym", "==", "null", ")", "{", "return", "null", ";", "}", "Tree", "parent", "=", "getCurrentPath", "(", ")", ".", "getParentPath", "(", ")", ".", "getLeaf", "(", ")", ";", "if", "(", "parent", ".", "getKind", "(", ")", "==", "Tree", ".", "Kind", ".", "CASE", "&&", "(", "(", "CaseTree", ")", "parent", ")", ".", "getExpression", "(", ")", ".", "equals", "(", "tree", ")", "&&", "sym", ".", "owner", ".", "getKind", "(", ")", "==", "ElementKind", ".", "ENUM", ")", "{", "// switch cases can refer to enum constants by simple name without importing them", "return", "null", ";", "}", "if", "(", "sym", ".", "owner", ".", "equals", "(", "owner", ")", "&&", "unit", ".", "starImportScope", ".", "includes", "(", "sym", ")", ")", "{", "fix", ".", "prefixWith", "(", "tree", ",", "owner", ".", "getSimpleName", "(", ")", "+", "\".\"", ")", ";", "}", "return", "null", ";", "}", "}", ".", "scan", "(", "unit", ",", "null", ")", ";", "}" ]

[ "Add", "an", "import", "for", "{" ]

[ "protected", "String", "formatFileSize", "(", "BigInteger", "fileLength", ",", "BigInteger", "divisor", ",", "String", "unit", ")", "{", "BigDecimal", "size", "=", "new", "BigDecimal", "(", "fileLength", ")", ";", "size", "=", "size", ".", "setScale", "(", "config", ".", "getFileSizeDisplayScale", "(", ")", ")", ".", "divide", "(", "new", "BigDecimal", "(", "divisor", ")", ",", "BigDecimal", ".", "ROUND_HALF_EVEN", ")", ";", "return", "String", ".", "format", "(", "\"%s %s\"", ",", "size", ".", "doubleValue", "(", ")", ",", "unit", ")", ";", "}" ]

[ "calculates", "the", "and", "formats", "files", "size" ]

[ "@", "Override", "public", "void", "openFile", "(", "String", "repositoryHash", ",", "String", "filename", ",", "Date", "currentDate", ")", "throws", "JournalException", "{", "try", "{", "super", ".", "testStateChange", "(", "State", ".", "FILE_OPEN", ")", ";", "journalFile", "=", "new", "TransportOutputFile", "(", "directory", ",", "filename", ")", ";", "xmlWriter", "=", "new", "IndentingXMLEventWriter", "(", "XMLOutputFactory", ".", "newInstance", "(", ")", ".", "createXMLEventWriter", "(", "journalFile", ".", "open", "(", ")", ")", ")", ";", "parent", ".", "writeDocumentHeader", "(", "xmlWriter", ",", "repositoryHash", ",", "currentDate", ")", ";", "super", ".", "setState", "(", "State", ".", "FILE_OPEN", ")", ";", "}", "catch", "(", "FactoryConfigurationError", "e", ")", "{", "throw", "new", "JournalException", "(", "e", ")", ";", "}", "catch", "(", "XMLStreamException", "e", ")", "{", "throw", "new", "JournalException", "(", "e", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "new", "JournalException", "(", "e", ")", ";", "}", "}" ]

[ "On", "a", "request", "to", "open", "the", "file", "<ul", ">", "<li", ">", "check", "that", "we", "are", "in", "a", "valid", "state", "<", "/", "li", ">", "<li", ">", "create", "the", "file", "<", "/", "li", ">", "<li", ">", "create", "the", "{" ]

[ "public", "static", "String", "toRangeArrayArgument", "(", "final", "Object", "base", ",", "final", "int", "rangeStart", ",", "final", "int", "rangeEnd", ")", "{", "return", "Nullables", ".", "toString", "(", "base", ",", "Strings", ".", "EMPTY_STRING", ")", "+", "'", "'", "+", "rangeStart", "+", "'", "'", "+", "rangeEnd", "+", "'", "'", ";", "}" ]

[ "Warning", ":", "uses", "default", "LML", "syntax", ".", "Will", "not", "work", "if", "you", "modified", "any", "LML", "markers", "." ]

[ "public", "KeyOperationResult", "unwrapKey", "(", "String", "vaultBaseUrl", ",", "String", "keyName", ",", "String", "keyVersion", ",", "JsonWebKeyEncryptionAlgorithm", "algorithm", ",", "byte", "[", "]", "value", ")", "{", "return", "unwrapKeyWithServiceResponseAsync", "(", "vaultBaseUrl", ",", "keyName", ",", "keyVersion", ",", "algorithm", ",", "value", ")", ".", "toBlocking", "(", ")", ".", "single", "(", ")", ".", "body", "(", ")", ";", "}" ]

[ "Unwraps", "a", "symmetric", "key", "using", "the", "specified", "key", "that", "was", "initially", "used", "for", "wrapping", "that", "key", ".", "The", "UNWRAP", "operation", "supports", "decryption", "of", "a", "symmetric", "key", "using", "the", "target", "key", "encryption", "key", ".", "This", "operation", "is", "the", "reverse", "of", "the", "WRAP", "operation", ".", "The", "UNWRAP", "operation", "applies", "to", "asymmetric", "and", "symmetric", "keys", "stored", "in", "Azure", "Key", "Vault", "since", "it", "uses", "the", "private", "portion", "of", "the", "key", ".", "This", "operation", "requires", "the", "keys", "/", "unwrapKey", "permission", "." ]

[ "public", "<", "T", ">", "T", "find", "(", "Entity", "where", ",", "RsHandler", "<", "T", ">", "rsh", ",", "String", "...", "fields", ")", "throws", "SQLException", "{", "return", "find", "(", "CollectionUtil", ".", "newArrayList", "(", "fields", ")", ",", "where", ",", "rsh", ")", ";", "}" ]

[ "查询，返回所有字段<br", ">", "查询条件为多个key", "value对表示，默认key", "=", "value，如果使用其它条件可以使用：where", ".", "put", "(", "key", "&gt", ";", "1", ")", "，value也可以传Condition对象，key被忽略" ]

[ "public", "static", "Integer", "getIntegerSetting", "(", "Map", "<", "String", ",", "Object", ">", "settings", ",", "String", "key", ",", "Integer", "defaultVal", ")", "{", "final", "Object", "value", "=", "settings", ".", "get", "(", "key", ")", ";", "if", "(", "value", "==", "null", ")", "{", "return", "defaultVal", ";", "}", "if", "(", "value", "instanceof", "Number", ")", "{", "return", "(", "(", "Number", ")", "value", ")", ".", "intValue", "(", ")", ";", "}", "if", "(", "value", "instanceof", "String", ")", "{", "try", "{", "return", "Integer", ".", "parseInt", "(", "(", "String", ")", "value", ")", ";", "}", "catch", "(", "NumberFormatException", "e", ")", "{", "return", "defaultVal", ";", "}", "}", "return", "defaultVal", ";", "}" ]

[ "Gets", "an", "Integer", "value", "for", "the", "key", "returning", "the", "default", "value", "given", "if", "not", "specified", "or", "not", "a", "valid", "numeric", "value", "." ]

[ "public", "static", "<", "VH", "extends", "PeasyViewHolder", ">", "VH", "GetViewHolder", "(", "PeasyViewHolder", "vh", ",", "Class", "<", "VH", ">", "cls", ")", "{", "return", "cls", ".", "cast", "(", "vh", ")", ";", "}" ]

[ "Help", "to", "cast", "provided", "PeasyViewHolder", "to", "its", "child", "class", "instance" ]

[ "public", "static", "void", "saveX509Cert", "(", "Certificate", "[", "]", "certs", ",", "File", "certFile", ")", "throws", "GeneralSecurityException", ",", "IOException", "{", "try", "(", "BufferedWriter", "writer", "=", "new", "BufferedWriter", "(", "new", "FileWriter", "(", "certFile", ")", ")", ")", "{", "for", "(", "Certificate", "cert", ":", "certs", ")", "{", "String", "certStr", "=", "Base64", ".", "getEncoder", "(", ")", ".", "encodeToString", "(", "cert", ".", "getEncoded", "(", ")", ")", ".", "replaceAll", "(", "\"(.{64})\"", ",", "\"$1\\n\"", ")", ";", "writer", ".", "write", "(", "BEGIN_CERT", ")", ";", "writer", ".", "newLine", "(", ")", ";", "writer", ".", "write", "(", "certStr", ")", ";", "writer", ".", "newLine", "(", ")", ";", "writer", ".", "write", "(", "END_CERT", ")", ";", "writer", ".", "newLine", "(", ")", ";", "}", "}", "}" ]

[ "Save", "a", "list", "of", "certificates", "into", "a", "file" ]

[ "public", "static", "int", "writeLength", "(", "int", "valueLength", ",", "OutputStream", "out", ")", "throws", "IOException", "{", "if", "(", "valueLength", "<", "128", ")", "{", "out", ".", "write", "(", "valueLength", ")", ";", "return", "1", ";", "}", "else", "if", "(", "valueLength", "<", "16384", ")", "{", "out", ".", "write", "(", "(", "valueLength", ">>", "8", ")", "|", "0x80", ")", ";", "out", ".", "write", "(", "valueLength", ")", ";", "return", "2", ";", "}", "else", "if", "(", "valueLength", "<", "2097152", ")", "{", "out", ".", "write", "(", "(", "valueLength", ">>", "16", ")", "|", "0xc0", ")", ";", "out", ".", "write", "(", "valueLength", ">>", "8", ")", ";", "out", ".", "write", "(", "valueLength", ")", ";", "return", "3", ";", "}", "else", "if", "(", "valueLength", "<", "268435456", ")", "{", "out", ".", "write", "(", "(", "valueLength", ">>", "24", ")", "|", "0xe0", ")", ";", "out", ".", "write", "(", "valueLength", ">>", "16", ")", ";", "out", ".", "write", "(", "valueLength", ">>", "8", ")", ";", "out", ".", "write", "(", "valueLength", ")", ";", "return", "4", ";", "}", "else", "{", "out", ".", "write", "(", "0xf0", ")", ";", "out", ".", "write", "(", "valueLength", ">>", "24", ")", ";", "out", ".", "write", "(", "valueLength", ">>", "16", ")", ";", "out", ".", "write", "(", "valueLength", ">>", "8", ")", ";", "out", ".", "write", "(", "valueLength", ")", ";", "return", "5", ";", "}", "}" ]

[ "Writes", "a", "positive", "length", "value", "in", "up", "to", "five", "bytes", "." ]

[ "static", "int", "getIndent", "(", "PropertySheetTable", "table", ",", "Item", "item", ")", "{", "int", "indent", ";", "if", "(", "item", ".", "isProperty", "(", ")", ")", "{", "// it is a property, it has no parent or a category, and no child\r", "if", "(", "(", "item", ".", "getParent", "(", ")", "==", "null", "||", "!", "item", ".", "getParent", "(", ")", ".", "isProperty", "(", ")", ")", "&&", "!", "item", ".", "hasToggle", "(", ")", ")", "{", "indent", "=", "table", ".", "getWantsExtraIndent", "(", ")", "?", "HOTSPOT_SIZE", ":", "0", ";", "}", "else", "{", "// it is a property with children\r", "if", "(", "item", ".", "hasToggle", "(", ")", ")", "{", "indent", "=", "item", ".", "getDepth", "(", ")", "*", "HOTSPOT_SIZE", ";", "}", "else", "{", "indent", "=", "(", "item", ".", "getDepth", "(", ")", "+", "1", ")", "*", "HOTSPOT_SIZE", ";", "}", "}", "if", "(", "table", ".", "getSheetModel", "(", ")", ".", "getMode", "(", ")", "==", "PropertySheet", ".", "VIEW_AS_CATEGORIES", "&&", "table", ".", "getWantsExtraIndent", "(", ")", ")", "{", "indent", "+=", "HOTSPOT_SIZE", ";", "}", "}", "else", "{", "// category has no indent\r", "indent", "=", "0", ";", "}", "return", "indent", ";", "}" ]

[ "Calculates", "the", "required", "left", "indent", "for", "a", "given", "item", "given", "its", "type", "and", "its", "hierarchy", "level", "." ]

[ "public", "boolean", "willFireOn", "(", "final", "Calendar", "aTest", ",", "final", "boolean", "dayOnly", ")", "{", "final", "Calendar", "test", "=", "(", "Calendar", ")", "aTest", ".", "clone", "(", ")", ";", "test", ".", "set", "(", "Calendar", ".", "MILLISECOND", ",", "0", ")", ";", "// don't compare millis.", "if", "(", "dayOnly", ")", "{", "test", ".", "set", "(", "Calendar", ".", "HOUR_OF_DAY", ",", "0", ")", ";", "test", ".", "set", "(", "Calendar", ".", "MINUTE", ",", "0", ")", ";", "test", ".", "set", "(", "Calendar", ".", "SECOND", ",", "0", ")", ";", "}", "final", "Date", "testTime", "=", "test", ".", "getTime", "(", ")", ";", "Date", "fta", "=", "getFireTimeAfter", "(", "new", "Date", "(", "test", ".", "getTime", "(", ")", ".", "getTime", "(", ")", "-", "1000", ")", ")", ";", "if", "(", "fta", "==", "null", ")", "return", "false", ";", "final", "Calendar", "p", "=", "Calendar", ".", "getInstance", "(", "test", ".", "getTimeZone", "(", ")", ",", "Locale", ".", "getDefault", "(", "Locale", ".", "Category", ".", "FORMAT", ")", ")", ";", "p", ".", "setTime", "(", "fta", ")", ";", "final", "int", "year", "=", "p", ".", "get", "(", "Calendar", ".", "YEAR", ")", ";", "final", "int", "month", "=", "p", ".", "get", "(", "Calendar", ".", "MONTH", ")", ";", "final", "int", "day", "=", "p", ".", "get", "(", "Calendar", ".", "DATE", ")", ";", "if", "(", "dayOnly", ")", "{", "return", "(", "year", "==", "test", ".", "get", "(", "Calendar", ".", "YEAR", ")", "&&", "month", "==", "test", ".", "get", "(", "Calendar", ".", "MONTH", ")", "&&", "day", "==", "test", ".", "get", "(", "Calendar", ".", "DATE", ")", ")", ";", "}", "while", "(", "fta", ".", "before", "(", "testTime", ")", ")", "{", "fta", "=", "getFireTimeAfter", "(", "fta", ")", ";", "}", "return", "fta", ".", "equals", "(", "testTime", ")", ";", "}" ]

[ "<p", ">", "Determines", "whether", "the", "date", "and", "(", "optionally", ")", "time", "of", "the", "given", "Calendar", "instance", "falls", "on", "a", "scheduled", "fire", "-", "time", "of", "this", "trigger", ".", "<", "/", "p", ">", "<p", ">", "Note", "that", "the", "value", "returned", "is", "NOT", "validated", "against", "the", "related", "{", "@link", "ICalendar", "}", "(", "if", "any", ")", "<", "/", "p", ">" ]

[ "public", "static", "boolean", "isHashed", "(", "String", "encoded_string", ")", "{", "String", "algorithm", "=", "getCryptoAlgorithm", "(", "encoded_string", ")", ";", "return", "isValidAlgorithm", "(", "algorithm", ",", "PasswordCipherUtil", ".", "getSupportedHashAlgorithms", "(", ")", ")", ";", "}" ]

[ "Determine", "if", "the", "provided", "string", "is", "hashed", "by", "examining", "the", "algorithm", "tag", ".", "Note", "that", "this", "method", "is", "only", "avaiable", "for", "the", "Liberty", "profile", "." ]

[ "private", "Message", "receiveSelected", "(", "TestContext", "context", ",", "String", "selectorString", ")", "{", "if", "(", "log", ".", "isDebugEnabled", "(", ")", ")", "{", "log", ".", "debug", "(", "\"Setting message selector: '\"", "+", "selectorString", "+", "\"'\"", ")", ";", "}", "Endpoint", "messageEndpoint", "=", "getOrCreateEndpoint", "(", "context", ")", ";", "Consumer", "consumer", "=", "messageEndpoint", ".", "createConsumer", "(", ")", ";", "if", "(", "consumer", "instanceof", "SelectiveConsumer", ")", "{", "if", "(", "receiveTimeout", ">", "0", ")", "{", "return", "(", "(", "SelectiveConsumer", ")", "messageEndpoint", ".", "createConsumer", "(", ")", ")", ".", "receive", "(", "context", ".", "replaceDynamicContentInString", "(", "selectorString", ")", ",", "context", ",", "receiveTimeout", ")", ";", "}", "else", "{", "return", "(", "(", "SelectiveConsumer", ")", "messageEndpoint", ".", "createConsumer", "(", ")", ")", ".", "receive", "(", "context", ".", "replaceDynamicContentInString", "(", "selectorString", ")", ",", "context", ",", "messageEndpoint", ".", "getEndpointConfiguration", "(", ")", ".", "getTimeout", "(", ")", ")", ";", "}", "}", "else", "{", "log", ".", "warn", "(", "String", ".", "format", "(", "\"Unable to receive selective with consumer implementation: '%s'\"", ",", "consumer", ".", "getClass", "(", ")", ")", ")", ";", "return", "receive", "(", "context", ")", ";", "}", "}" ]

[ "Receives", "the", "message", "with", "the", "respective", "message", "receiver", "implementation", "also", "using", "a", "message", "selector", "." ]

[ "private", "void", "_serializeDateTime", "(", "DateTime", "dateTime", ",", "StringBuilder", "sb", ")", "throws", "ConverterException", "{", "try", "{", "TimeZone", "tz", "=", "ThreadLocalPageContext", ".", "getTimeZone", "(", ")", ";", "sb", ".", "append", "(", "goIn", "(", ")", ")", ";", "sb", ".", "append", "(", "\"createDateTime(\"", ")", ";", "sb", ".", "append", "(", "DateFormat", ".", "call", "(", "null", ",", "dateTime", ",", "\"yyyy,m,d\"", ",", "tz", ")", ")", ";", "sb", ".", "append", "(", "'", "'", ")", ";", "sb", ".", "append", "(", "TimeFormat", ".", "call", "(", "null", ",", "dateTime", ",", "\"H,m,s,l,\"", ",", "tz", ")", ")", ";", "sb", ".", "append", "(", "'", "'", ")", ".", "append", "(", "tz", ".", "getID", "(", ")", ")", ".", "append", "(", "'", "'", ")", ";", "sb", ".", "append", "(", "'", "'", ")", ";", "}", "catch", "(", "PageException", "e", ")", "{", "throw", "toConverterException", "(", "e", ")", ";", "}", "}" ]

[ "serialize", "a", "DateTime" ]

[ "public", "static", "synchronized", "void", "setServiceEnabled", "(", "XMPPConnection", "connection", ",", "boolean", "enabled", ")", "{", "if", "(", "isServiceEnabled", "(", "connection", ")", "==", "enabled", ")", "return", ";", "if", "(", "enabled", ")", "{", "ServiceDiscoveryManager", ".", "getInstanceFor", "(", "connection", ")", ".", "addFeature", "(", "XHTMLExtension", ".", "NAMESPACE", ")", ";", "}", "else", "{", "ServiceDiscoveryManager", ".", "getInstanceFor", "(", "connection", ")", ".", "removeFeature", "(", "XHTMLExtension", ".", "NAMESPACE", ")", ";", "}", "}" ]

[ "Enables", "or", "disables", "the", "XHTML", "support", "on", "a", "given", "connection", ".", "<p", ">" ]

[ "public", "synchronized", "void", "pushExternalCacheFragment", "(", "ExternalInvalidation", "externalCacheFragment", ",", "DCache", "cache", ")", "{", "BatchUpdateList", "bul", "=", "getUpdateList", "(", "cache", ")", ";", "bul", ".", "pushECFEvents", ".", "add", "(", "externalCacheFragment", ")", ";", "}" ]

[ "This", "allows", "an", "external", "cache", "fragment", "to", "be", "added", "to", "the", "BatchUpdateDaemon", "." ]

[ "public", "static", "File", "[", "]", "getHadoopDependencyFilesToLoad", "(", "List", "<", "String", ">", "hadoopDependencyCoordinates", ",", "ExtensionsConfig", "extensionsConfig", ")", "{", "final", "File", "rootHadoopDependenciesDir", "=", "new", "File", "(", "extensionsConfig", ".", "getHadoopDependenciesDir", "(", ")", ")", ";", "if", "(", "rootHadoopDependenciesDir", ".", "exists", "(", ")", "&&", "!", "rootHadoopDependenciesDir", ".", "isDirectory", "(", ")", ")", "{", "throw", "new", "ISE", "(", "\"Root Hadoop dependencies directory [%s] is not a directory!?\"", ",", "rootHadoopDependenciesDir", ")", ";", "}", "final", "File", "[", "]", "hadoopDependenciesToLoad", "=", "new", "File", "[", "hadoopDependencyCoordinates", ".", "size", "(", ")", "]", ";", "int", "i", "=", "0", ";", "for", "(", "final", "String", "coordinate", ":", "hadoopDependencyCoordinates", ")", "{", "final", "DefaultArtifact", "artifact", "=", "new", "DefaultArtifact", "(", "coordinate", ")", ";", "final", "File", "hadoopDependencyDir", "=", "new", "File", "(", "rootHadoopDependenciesDir", ",", "artifact", ".", "getArtifactId", "(", ")", ")", ";", "final", "File", "versionDir", "=", "new", "File", "(", "hadoopDependencyDir", ",", "artifact", ".", "getVersion", "(", ")", ")", ";", "// find the hadoop dependency with the version specified in coordinate", "if", "(", "!", "hadoopDependencyDir", ".", "isDirectory", "(", ")", "||", "!", "versionDir", ".", "isDirectory", "(", ")", ")", "{", "throw", "new", "ISE", "(", "\"Hadoop dependency [%s] didn't exist!?\"", ",", "versionDir", ".", "getAbsolutePath", "(", ")", ")", ";", "}", "hadoopDependenciesToLoad", "[", "i", "++", "]", "=", "versionDir", ";", "}", "return", "hadoopDependenciesToLoad", ";", "}" ]

[ "Find", "all", "the", "hadoop", "dependencies", "that", "should", "be", "loaded", "by", "druid" ]

[ "private", "static", "String", "escapeKeyword", "(", "String", "symbol", ",", "EscapeStrategy", "strategy", ")", "{", "if", "(", "tsKeywords", ".", "contains", "(", "symbol", ")", ")", "{", "if", "(", "strategy", ".", "equals", "(", "EscapeStrategy", ".", "MANGLE", ")", ")", "{", "return", "symbol", "+", "\"$\"", ";", "}", "else", "{", "return", "\"\\\"\"", "+", "symbol", "+", "\"\\\"\"", ";", "}", "}", "else", "{", "return", "symbol", ";", "}", "}" ]

[ "Returns", "the", "escaped", "Pegasus", "symbol", "for", "use", "in", "Typescript", "source", "code", "." ]

[ "public", "PutItemResult", "putItem", "(", "PutItemRequest", "putItemRequest", ")", "throws", "AmazonServiceException", ",", "AmazonClientException", "{", "ExecutionContext", "executionContext", "=", "createExecutionContext", "(", "putItemRequest", ")", ";", "AWSRequestMetrics", "awsRequestMetrics", "=", "executionContext", ".", "getAwsRequestMetrics", "(", ")", ";", "Request", "<", "PutItemRequest", ">", "request", "=", "marshall", "(", "putItemRequest", ",", "new", "PutItemRequestMarshaller", "(", ")", ",", "executionContext", ".", "getAwsRequestMetrics", "(", ")", ")", ";", "// Binds the request metrics to the current request.", "request", ".", "setAWSRequestMetrics", "(", "awsRequestMetrics", ")", ";", "Unmarshaller", "<", "PutItemResult", ",", "JsonUnmarshallerContext", ">", "unmarshaller", "=", "new", "PutItemResultJsonUnmarshaller", "(", ")", ";", "JsonResponseHandler", "<", "PutItemResult", ">", "responseHandler", "=", "new", "JsonResponseHandler", "<", "PutItemResult", ">", "(", "unmarshaller", ")", ";", "return", "invoke", "(", "request", ",", "responseHandler", ",", "executionContext", ")", ";", "}" ]

[ "<p", ">", "Creates", "a", "new", "item", "or", "replaces", "an", "old", "item", "with", "a", "new", "item", "(", "including", "all", "the", "attributes", ")", ".", "<", "/", "p", ">", "<p", ">", "If", "an", "item", "already", "exists", "in", "the", "specified", "table", "with", "the", "same", "primary", "key", "the", "new", "item", "completely", "replaces", "the", "existing", "item", ".", "You", "can", "perform", "a", "conditional", "put", "(", "insert", "a", "new", "item", "if", "one", "with", "the", "specified", "primary", "key", "doesn", "t", "exist", ")", "or", "replace", "an", "existing", "item", "if", "it", "has", "certain", "attribute", "values", ".", "<", "/", "p", ">" ]

[ "protected", "static", "int", "countPreceding", "(", "String", "line", ",", "int", "index", ",", "char", "ch", ")", "{", "int", "i", ";", "for", "(", "i", "=", "index", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "if", "(", "line", ".", "charAt", "(", "i", ")", "!=", "ch", ")", "{", "break", ";", "}", "}", "return", "index", "-", "1", "-", "i", ";", "}" ]

[ "Counts", "the", "number", "of", "successive", "times", "ch", "appears", "in", "the", "line", "before", "the", "position", "indicated", "by", "the", "index", ".", "<p", ">" ]

[ "public", "static", "void", "applyDistortion", "(", "Point2D_F64", "normPt", ",", "double", "[", "]", "radial", ",", "double", "t1", ",", "double", "t2", ")", "{", "final", "double", "x", "=", "normPt", ".", "x", ";", "final", "double", "y", "=", "normPt", ".", "y", ";", "double", "a", "=", "0", ";", "double", "r2", "=", "x", "*", "x", "+", "y", "*", "y", ";", "double", "r2i", "=", "r2", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "radial", ".", "length", ";", "i", "++", ")", "{", "a", "+=", "radial", "[", "i", "]", "*", "r2i", ";", "r2i", "*=", "r2", ";", "}", "normPt", ".", "x", "=", "x", "+", "x", "*", "a", "+", "2", "*", "t1", "*", "x", "*", "y", "+", "t2", "*", "(", "r2", "+", "2", "*", "x", "*", "x", ")", ";", "normPt", ".", "y", "=", "y", "+", "y", "*", "a", "+", "t1", "*", "(", "r2", "+", "2", "*", "y", "*", "y", ")", "+", "2", "*", "t2", "*", "x", "*", "y", ";", "}" ]

[ "Applies", "radial", "and", "tangential", "distortion", "to", "the", "normalized", "image", "coordinate", "." ]

[ "private", "void", "readExceptions", "(", "Project", ".", "Calendars", ".", "Calendar", "calendar", ",", "ProjectCalendar", "bc", ")", "{", "Project", ".", "Calendars", ".", "Calendar", ".", "Exceptions", "exceptions", "=", "calendar", ".", "getExceptions", "(", ")", ";", "if", "(", "exceptions", "!=", "null", ")", "{", "for", "(", "Project", ".", "Calendars", ".", "Calendar", ".", "Exceptions", ".", "Exception", "exception", ":", "exceptions", ".", "getException", "(", ")", ")", "{", "readException", "(", "bc", ",", "exception", ")", ";", "}", "}", "}" ]

[ "Reads", "any", "exceptions", "present", "in", "the", "file", ".", "This", "is", "only", "used", "in", "MSPDI", "file", "versions", "saved", "by", "Project", "2007", "and", "later", "." ]

[ "public", "void", "setSwipeItemMenuEnabled", "(", "int", "position", ",", "boolean", "enabled", ")", "{", "if", "(", "enabled", ")", "{", "if", "(", "mDisableSwipeItemMenuList", ".", "contains", "(", "position", ")", ")", "{", "mDisableSwipeItemMenuList", ".", "remove", "(", "Integer", ".", "valueOf", "(", "position", ")", ")", ";", "}", "}", "else", "{", "if", "(", "!", "mDisableSwipeItemMenuList", ".", "contains", "(", "position", ")", ")", "{", "mDisableSwipeItemMenuList", ".", "add", "(", "position", ")", ";", "}", "}", "}" ]

[ "Set", "the", "item", "menu", "to", "enable", "status", "." ]

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

[ "Retrieve", "the", "variable", "identified", "by", "variable", "name", "." ]

[ "public", "final", "BufferedImage", "decode", "(", ")", "throws", "IOException", "{", "if", "(", "!", "validPNG", ")", "{", "return", "null", ";", "}", "ColorModel", "cmodel", "=", "new", "ComponentColorModel", "(", "COLOR_SPACE", ",", "BITS", ",", "false", ",", "false", ",", "Transparency", ".", "OPAQUE", ",", "DATA_TYPE", ")", ";", "SampleModel", "smodel", "=", "new", "ComponentSampleModel", "(", "DATA_TYPE", ",", "width", ",", "height", ",", "3", ",", "width", "*", "3", ",", "BAND_OFFSETS", ")", ";", "byte", "[", "]", "bytes", "=", "new", "byte", "[", "width", "*", "height", "*", "3", "]", ";", "// must new each time!", "byte", "[", "]", "[", "]", "data", "=", "new", "byte", "[", "]", "[", "]", "{", "bytes", "}", ";", "ByteBuffer", "buffer", "=", "ByteBuffer", ".", "wrap", "(", "bytes", ")", ";", "decode", "(", "buffer", ",", "TextureFormat", ".", "RGB", ")", ";", "DataBufferByte", "dbuf", "=", "new", "DataBufferByte", "(", "data", ",", "bytes", ".", "length", ",", "OFFSET", ")", ";", "WritableRaster", "raster", "=", "Raster", ".", "createWritableRaster", "(", "smodel", ",", "dbuf", ",", "null", ")", ";", "BufferedImage", "bi", "=", "new", "BufferedImage", "(", "cmodel", ",", "raster", ",", "false", ",", "null", ")", ";", "bi", ".", "flush", "(", ")", ";", "return", "bi", ";", "}" ]

[ "read", "just", "one", "png", "file", "if", "invalid", "return", "null" ]

[ "protected", "static", "String", "getClassName", "(", "ProgramElementDoc", "doc", ",", "boolean", "binaryName", ")", "{", "PackageDoc", "containingPackage", "=", "doc", ".", "containingPackage", "(", ")", ";", "String", "className", "=", "doc", ".", "name", "(", ")", ";", "if", "(", "binaryName", ")", "{", "className", "=", "className", ".", "replaceAll", "(", "\"\\\\.\"", ",", "\"\\\\$\"", ")", ";", "}", "return", "containingPackage", ".", "name", "(", ")", ".", "length", "(", ")", ">", "0", "?", "String", ".", "format", "(", "\"%s.%s\"", ",", "containingPackage", ".", "name", "(", ")", ",", "className", ")", ":", "String", ".", "format", "(", "\"%s\"", ",", "className", ")", ";", "}" ]

[ "Reconstitute", "the", "class", "name", "from", "the", "given", "class", "JavaDoc", "object", "." ]

[ "public", "static", "int", "cusolverSpScsreigvsiHost", "(", "cusolverSpHandle", "handle", ",", "int", "m", ",", "int", "nnz", ",", "cusparseMatDescr", "descrA", ",", "Pointer", "csrValA", ",", "Pointer", "csrRowPtrA", ",", "Pointer", "csrColIndA", ",", "float", "mu0", ",", "Pointer", "x0", ",", "int", "maxite", ",", "float", "tol", ",", "Pointer", "mu", ",", "Pointer", "x", ")", "{", "return", "checkResult", "(", "cusolverSpScsreigvsiHostNative", "(", "handle", ",", "m", ",", "nnz", ",", "descrA", ",", "csrValA", ",", "csrRowPtrA", ",", "csrColIndA", ",", "mu0", ",", "x0", ",", "maxite", ",", "tol", ",", "mu", ",", "x", ")", ")", ";", "}" ]

[ "<pre", ">", "---------", "CPU", "eigenvalue", "solver", "by", "shift", "inverse", "solve", "A", "*", "x", "=", "lambda", "*", "x", "where", "lambda", "is", "the", "eigenvalue", "nearest", "mu0", ".", "[", "eig", "]", "stands", "for", "eigenvalue", "solver", "[", "si", "]", "stands", "for", "shift", "-", "inverse", "<", "/", "pre", ">" ]

[ "public", "OvhTask", "packName_emailPro_services_POST", "(", "String", "packName", ",", "String", "email", ",", "String", "password", ")", "throws", "IOException", "{", "String", "qPath", "=", "\"/pack/xdsl/{packName}/emailPro/services\"", ";", "StringBuilder", "sb", "=", "path", "(", "qPath", ",", "packName", ")", ";", "HashMap", "<", "String", ",", "Object", ">", "o", "=", "new", "HashMap", "<", "String", ",", "Object", ">", "(", ")", ";", "addBody", "(", "o", ",", "\"email\"", ",", "email", ")", ";", "addBody", "(", "o", ",", "\"password\"", ",", "password", ")", ";", "String", "resp", "=", "exec", "(", "qPath", ",", "\"POST\"", ",", "sb", ".", "toString", "(", ")", ",", "o", ")", ";", "return", "convertTo", "(", "resp", ",", "OvhTask", ".", "class", ")", ";", "}" ]

[ "Activate", "an", "Email", "Pro", "service" ]

[ "public", "static", "void", "addInPlace", "(", "double", "[", "]", "a", ",", "double", "b", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "a", ".", "length", ";", "i", "++", ")", "{", "a", "[", "i", "]", "=", "a", "[", "i", "]", "+", "b", ";", "}", "}" ]

[ "Increases", "the", "values", "in", "this", "array", "by", "b", ".", "Does", "it", "in", "place", "." ]

[ "@", "Override", "public", "void", "put", "(", "String", "name", ",", "Scriptable", "start", ",", "Object", "value", ")", "{", "if", "(", "!", "isSymbol", "(", ")", ")", "{", "super", ".", "put", "(", "name", ",", "start", ",", "value", ")", ";", "}", "else", "if", "(", "Context", ".", "getCurrentContext", "(", ")", ".", "isStrictMode", "(", ")", ")", "{", "throw", "ScriptRuntime", ".", "typeError0", "(", "\"msg.no.assign.symbol.strict\"", ")", ";", "}", "}" ]

[ "Symbol", "objects", "have", "a", "special", "property", "that", "one", "cannot", "add", "properties", "." ]

[ "public", "static", "String", "getKeywordValue", "(", "String", "localeID", ",", "String", "keywordName", ")", "{", "return", "new", "LocaleIDParser", "(", "localeID", ")", ".", "getKeywordValue", "(", "keywordName", ")", ";", "}" ]

[ "<strong", ">", "[", "icu", "]", "<", "/", "strong", ">", "Returns", "the", "value", "for", "a", "keyword", "in", "the", "specified", "locale", ".", "If", "the", "keyword", "is", "not", "defined", "returns", "null", ".", "The", "locale", "name", "does", "not", "need", "to", "be", "normalized", "." ]

[ "public", "Observable", "<", "AgreementTermsInner", ">", "cancelAsync", "(", "String", "publisherId", ",", "String", "offerId", ",", "String", "planId", ")", "{", "return", "cancelWithServiceResponseAsync", "(", "publisherId", ",", "offerId", ",", "planId", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "AgreementTermsInner", ">", ",", "AgreementTermsInner", ">", "(", ")", "{", "@", "Override", "public", "AgreementTermsInner", "call", "(", "ServiceResponse", "<", "AgreementTermsInner", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Cancel", "marketplace", "terms", "." ]

[ "private", "RestException", "buildKnown", "(", "Constructor", "<", "RestException", ">", "constructor", ",", "RestFailure", "failure", ")", "{", "try", "{", "return", "constructor", ".", "newInstance", "(", "failure", ".", "exception", ".", "detail", ",", "null", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "return", "buildUnknown", "(", "failure", ")", ";", "}", "}" ]

[ "Build", "an", "exception", "for", "a", "known", "exception", "type" ]