Datasets:

---

stojchet

/

base_prediction_dataset

like 0

[ "public", "CustomAttribute", "createCustomAttribute", "(", "final", "Object", "userIdOrUsername", ",", "final", "String", "key", ",", "final", "String", "value", ")", "throws", "GitLabApiException", "{", "if", "(", "Objects", ".", "isNull", "(", "key", ")", "||", "key", ".", "trim", "(", ")", ".", "isEmpty", "(", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Key can't be null or empty\"", ")", ";", "}", "if", "(", "Objects", ".", "isNull", "(", "value", ")", "||", "value", ".", "trim", "(", ")", ".", "isEmpty", "(", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Value can't be null or empty\"", ")", ";", "}", "GitLabApiForm", "formData", "=", "new", "GitLabApiForm", "(", ")", ".", "withParam", "(", "\"value\"", ",", "value", ")", ";", "Response", "response", "=", "put", "(", "Response", ".", "Status", ".", "OK", ",", "formData", ".", "asMap", "(", ")", ",", "\"users\"", ",", "getUserIdOrUsername", "(", "userIdOrUsername", ")", ",", "\"custom_attributes\"", ",", "key", ")", ";", "return", "(", "response", ".", "readEntity", "(", "CustomAttribute", ".", "class", ")", ")", ";", "}" ]

[ "Creates", "custom", "attribute", "for", "the", "given", "user" ]

[ "@", "SuppressWarnings", "(", "\"SameParameterValue\"", ")", "public", "Message", "menuRequest", "(", "Message", ".", "KnownType", "requestType", ",", "Message", ".", "MenuIdentifier", "targetMenu", ",", "CdjStatus", ".", "TrackSourceSlot", "slot", ",", "Field", "...", "arguments", ")", "throws", "IOException", "{", "return", "menuRequestTyped", "(", "requestType", ",", "targetMenu", ",", "slot", ",", "CdjStatus", ".", "TrackType", ".", "REKORDBOX", ",", "arguments", ")", ";", "}" ]

[ "Send", "a", "request", "for", "a", "menu", "that", "we", "will", "retrieve", "items", "from", "in", "subsequent", "requests", ".", "This", "variant", "works", "for", "nearly", "all", "menus", "but", "when", "you", "are", "trying", "to", "request", "metadata", "for", "an", "unanalyzed", "(", "non", "-", "rekordbox", ")", "track", "you", "need", "to", "use", "{", "@link", "#menuRequestTyped", "(", "Message", ".", "KnownType", "Message", ".", "MenuIdentifier", "CdjStatus", ".", "TrackSourceSlot", "CdjStatus", ".", "TrackType", "Field", "...", ")", "}", "and", "specify", "the", "actual", "type", "of", "the", "track", "whose", "metadata", "you", "want", "to", "retrieve", "." ]

[ "public", "void", "undeployVM", "(", "String", "vrpId", ",", "VirtualMachine", "vm", ",", "ClusterComputeResource", "cluster", ")", "throws", "InvalidState", ",", "NotFound", ",", "RuntimeFault", ",", "RemoteException", "{", "getVimService", "(", ")", ".", "undeployVM", "(", "getMOR", "(", ")", ",", "vrpId", ",", "vm", ".", "getMOR", "(", ")", ",", "cluster", ".", "getMOR", "(", ")", ")", ";", "}" ]

[ "Undeploy", "a", "VM", "in", "given", "VRP", "hub", "pair", "." ]

[ "@", "Override", "public", "synchronized", "void", "remove", "(", "URI", "jobURI", ")", "{", "Preconditions", ".", "checkState", "(", "state", "(", ")", "==", "State", ".", "RUNNING", ",", "String", ".", "format", "(", "\"%s is not running.\"", ",", "this", ".", "getClass", "(", ")", ".", "getName", "(", ")", ")", ")", ";", "try", "{", "long", "startTime", "=", "System", ".", "currentTimeMillis", "(", ")", ";", "JobSpec", "jobSpec", "=", "getJobSpec", "(", "jobURI", ")", ";", "Path", "jobSpecPath", "=", "getPathForURI", "(", "this", ".", "jobConfDirPath", ",", "jobURI", ")", ";", "if", "(", "fs", ".", "exists", "(", "jobSpecPath", ")", ")", "{", "fs", ".", "delete", "(", "jobSpecPath", ",", "false", ")", ";", "this", ".", "mutableMetrics", ".", "updateRemoveJobTime", "(", "startTime", ")", ";", "this", ".", "listeners", ".", "onDeleteJob", "(", "jobURI", ",", "jobSpec", ".", "getVersion", "(", ")", ")", ";", "}", "else", "{", "LOGGER", ".", "warn", "(", "\"No file with URI:\"", "+", "jobSpecPath", "+", "\" is found. Deletion failed.\"", ")", ";", "}", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "new", "RuntimeException", "(", "\"When removing a JobConf. file, issues unexpected happen:\"", "+", "e", ".", "getMessage", "(", ")", ")", ";", "}", "catch", "(", "SpecNotFoundException", "e", ")", "{", "LOGGER", ".", "warn", "(", "\"No file with URI:\"", "+", "jobURI", "+", "\" is found. Deletion failed.\"", ")", ";", "}", "}" ]

[ "Allow", "user", "to", "programmatically", "delete", "a", "new", "JobSpec", ".", "This", "method", "is", "designed", "to", "be", "reentrant", "." ]

[ "public", "static", "StringTemplate", "stringTemplate", "(", "String", "template", ",", "List", "<", "?", ">", "args", ")", "{", "return", "stringTemplate", "(", "createTemplate", "(", "template", ")", ",", "args", ")", ";", "}" ]

[ "Create", "a", "new", "Template", "expression" ]

[ "public", "void", "rotate", "(", "float", "w", ",", "float", "x", ",", "float", "y", ",", "float", "z", ")", "{", "NativeTransform", ".", "rotate", "(", "getNative", "(", ")", ",", "w", ",", "x", ",", "y", ",", "z", ")", ";", "}" ]

[ "Modify", "the", "tranform", "s", "current", "rotation", "in", "quaternion", "terms", "." ]

[ "private", "void", "secureCookie", "(", "Cookie", "cookie", ",", "HttpServletRequest", "request", ")", "{", "// if we can mark the cookie HTTP only, do so to protect this cookie even in case of XSS vulnerability.", "if", "(", "SET_HTTP_ONLY", "!=", "null", ")", "{", "try", "{", "SET_HTTP_ONLY", ".", "invoke", "(", "cookie", ",", "true", ")", ";", "}", "catch", "(", "IllegalAccessException", "|", "InvocationTargetException", "e", ")", "{", "// ignore", "}", "}", "// if the user is running Jenkins over HTTPS, we also want to prevent the cookie from leaking in HTTP.", "// whether the login is done over HTTPS or not would be a good enough approximation of whether Jenkins runs in", "// HTTPS or not, so use that.", "cookie", ".", "setSecure", "(", "request", ".", "isSecure", "(", ")", ")", ";", "}" ]

[ "Force", "always", "the", "http", "-", "only", "flag", "and", "depending", "on", "the", "request", "put", "also", "the", "secure", "flag", "." ]

[ "public", "<", "A", ">", "A", "register", "(", "final", "String", "name", ",", "final", "Type", "clazz", ",", "final", "A", "rs", ")", "{", "return", "register", "(", "true", ",", "name", ",", "clazz", ",", "rs", ")", ";", "}" ]

[ "将对象以指定资源名和类型注入到资源池中，并同步已被注入的资源" ]

[ "protected", "void", "deliverLifecycleAnnouncement", "(", "final", "Logger", "logger", ",", "final", "boolean", "starting", ")", "{", "new", "Thread", "(", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "for", "(", "final", "LifecycleListener", "listener", ":", "getLifecycleListeners", "(", ")", ")", "{", "try", "{", "if", "(", "starting", ")", "{", "listener", ".", "started", "(", "LifecycleParticipant", ".", "this", ")", ";", "}", "else", "{", "listener", ".", "stopped", "(", "LifecycleParticipant", ".", "this", ")", ";", "}", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Problem delivering lifecycle announcement to listener\"", ",", "t", ")", ";", "}", "}", "}", "}", ",", "\"Lifecycle announcement delivery\"", ")", ".", "start", "(", ")", ";", "}" ]

[ "Send", "a", "lifecycle", "announcement", "to", "all", "registered", "listeners", "." ]

[ "public", "void", "putFunctionForId", "(", "String", "id", ",", "DifferentialFunction", "function", ")", "{", "if", "(", "ops", ".", "containsKey", "(", "id", ")", "&&", "ops", ".", "get", "(", "id", ")", ".", "getOp", "(", ")", "==", "null", ")", "{", "throw", "new", "ND4JIllegalStateException", "(", "\"Function by id already exists!\"", ")", ";", "}", "else", "if", "(", "function", "instanceof", "SDVariable", ")", "{", "throw", "new", "ND4JIllegalStateException", "(", "\"Function must not be a variable!\"", ")", ";", "}", "if", "(", "ops", ".", "containsKey", "(", "id", ")", ")", "{", "}", "else", "{", "ops", ".", "put", "(", "id", ",", "SameDiffOp", ".", "builder", "(", ")", ".", "name", "(", "id", ")", ".", "op", "(", "function", ")", ".", "build", "(", ")", ")", ";", "}", "}" ]

[ "Put", "the", "function", "for", "the", "given", "id" ]

[ "public", "static", "<", "T", ">", "ArgumentProcessor", "<", "T", ">", "forType", "(", "Class", "<", "?", "extends", "T", ">", "beanType", ")", "{", "return", "newInstance", "(", "beanType", ",", "new", "GnuParser", "(", ")", ")", ";", "}" ]

[ "Create", "new", "instance", "with", "default", "parser", "a", "{", "@link", "GnuParser", "}" ]

[ "public", "void", "addObjective", "(", "Objective", "<", "?", "super", "SolutionType", ",", "?", "super", "DataType", ">", "objective", ",", "double", "weight", ")", "{", "// check weight", "if", "(", "weight", ">", "0.0", ")", "{", "// add objective to map", "weights", ".", "put", "(", "objective", ",", "weight", ")", ";", "}", "else", "{", "throw", "new", "IllegalArgumentException", "(", "\"Error in weighted index: each objective's weight should be strictly positive.\"", ")", ";", "}", "}" ]

[ "Add", "an", "objective", "with", "corresponding", "weight", ".", "Any", "objective", "designed", "for", "the", "solution", "type", "and", "data", "type", "of", "this", "multi", "-", "objective", "(", "or", "for", "more", "general", "solution", "or", "data", "types", ")", "can", "be", "added", ".", "The", "specified", "weight", "should", "be", "strictly", "positive", "if", "not", "an", "exception", "will", "be", "thrown", "." ]

[ "private", "void", "updateWaveform", "(", "WaveformPreview", "preview", ")", "{", "this", ".", "preview", ".", "set", "(", "preview", ")", ";", "if", "(", "preview", "==", "null", ")", "{", "waveformImage", ".", "set", "(", "null", ")", ";", "}", "else", "{", "BufferedImage", "image", "=", "new", "BufferedImage", "(", "preview", ".", "segmentCount", ",", "preview", ".", "maxHeight", ",", "BufferedImage", ".", "TYPE_INT_RGB", ")", ";", "Graphics", "g", "=", "image", ".", "getGraphics", "(", ")", ";", "g", ".", "setColor", "(", "Color", ".", "BLACK", ")", ";", "g", ".", "fillRect", "(", "0", ",", "0", ",", "preview", ".", "segmentCount", ",", "preview", ".", "maxHeight", ")", ";", "for", "(", "int", "segment", "=", "0", ";", "segment", "<", "preview", ".", "segmentCount", ";", "segment", "++", ")", "{", "g", ".", "setColor", "(", "preview", ".", "segmentColor", "(", "segment", ",", "false", ")", ")", ";", "g", ".", "drawLine", "(", "segment", ",", "preview", ".", "maxHeight", ",", "segment", ",", "preview", ".", "maxHeight", "-", "preview", ".", "segmentHeight", "(", "segment", ",", "false", ")", ")", ";", "if", "(", "preview", ".", "isColor", ")", "{", "// We have a front color segment to draw on top.", "g", ".", "setColor", "(", "preview", ".", "segmentColor", "(", "segment", ",", "true", ")", ")", ";", "g", ".", "drawLine", "(", "segment", ",", "preview", ".", "maxHeight", ",", "segment", ",", "preview", ".", "maxHeight", "-", "preview", ".", "segmentHeight", "(", "segment", ",", "true", ")", ")", ";", "}", "}", "waveformImage", ".", "set", "(", "image", ")", ";", "}", "}" ]

[ "Create", "an", "image", "of", "the", "proper", "size", "to", "hold", "a", "new", "waveform", "preview", "image", "and", "draw", "it", "." ]

[ "@", "Override", "public", "void", "process", "(", "Node", "externs", ",", "Node", "root", ")", "{", "checkState", "(", "compiler", ".", "getLifeCycleStage", "(", ")", ".", "isNormalized", "(", ")", ")", ";", "if", "(", "!", "allowRemovalOfExternProperties", ")", "{", "referencedPropertyNames", ".", "addAll", "(", "compiler", ".", "getExternProperties", "(", ")", ")", ";", "}", "traverseAndRemoveUnusedReferences", "(", "root", ")", ";", "// This pass may remove definitions of getter or setter properties.", "GatherGettersAndSetterProperties", ".", "update", "(", "compiler", ",", "externs", ",", "root", ")", ";", "}" ]

[ "Traverses", "the", "root", "removing", "all", "unused", "variables", ".", "Multiple", "traversals", "may", "occur", "to", "ensure", "all", "unused", "variables", "are", "removed", "." ]

[ "public", "static", "UserAgentStringParser", "getCachingAndUpdatingParser", "(", "final", "URL", "dataUrl", ",", "final", "URL", "versionUrl", ",", "final", "URL", "fallbackDataURL", ",", "final", "URL", "fallbackVersionURL", ")", "{", "return", "CachingAndUpdatingParserHolder", ".", "getParser", "(", "dataUrl", ",", "versionUrl", ",", "getCustomFallbackXmlDataStore", "(", "fallbackDataURL", ",", "fallbackVersionURL", ")", ")", ";", "}" ]

[ "Returns", "an", "implementation", "of", "{", "@link", "UserAgentStringParser", "}", "which", "checks", "at", "regular", "intervals", "for", "new", "versions", "of", "<em", ">", "UAS", "data<", "/", "em", ">", "(", "also", "known", "as", "database", ")", ".", "When", "newer", "data", "available", "it", "automatically", "loads", "and", "updates", "it", ".", "Additionally", "the", "loaded", "data", "are", "stored", "in", "a", "cache", "file", "." ]

[ "private", "static", "Partition", "createRangeSubPartitionWithPartition", "(", "SqlgGraph", "sqlgGraph", ",", "Partition", "parentPartition", ",", "String", "name", ",", "String", "from", ",", "String", "to", ",", "PartitionType", "partitionType", ",", "String", "partitionExpression", ")", "{", "Preconditions", ".", "checkArgument", "(", "!", "parentPartition", ".", "getAbstractLabel", "(", ")", ".", "getSchema", "(", ")", ".", "isSqlgSchema", "(", ")", ",", "\"createRangeSubPartitionWithPartition may not be called for \\\"%s\\\"\"", ",", "Topology", ".", "SQLG_SCHEMA", ")", ";", "Partition", "partition", "=", "new", "Partition", "(", "sqlgGraph", ",", "parentPartition", ",", "name", ",", "from", ",", "to", ",", "partitionType", ",", "partitionExpression", ")", ";", "partition", ".", "createRangePartitionOnDb", "(", ")", ";", "TopologyManager", ".", "addSubPartition", "(", "sqlgGraph", ",", "partition", ")", ";", "partition", ".", "committed", "=", "false", ";", "return", "partition", ";", "}" ]

[ "Create", "a", "range", "partition", "on", "an", "existing", "{", "@link", "Partition", "}" ]

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

[ "Serializes", "the", "content", "of", "the", "object", "into", "the", "{", "@link", "com", ".", "google", ".", "gwt", ".", "user", ".", "client", ".", "rpc", ".", "SerializationStreamWriter", "}", "." ]

[ "public", "static", "CharSource", "asCompressedCharSource", "(", "File", "f", ",", "Charset", "charSet", ")", "throws", "IOException", "{", "return", "asCompressedByteSource", "(", "f", ")", ".", "asCharSource", "(", "charSet", ")", ";", "}" ]

[ "Just", "like", "{" ]

[ "public", "static", "Object", "removeRef", "(", "Object", "[", "]", "list", ",", "Object", "element", ")", "{", "return", "remove", "(", "REFERENCE_COMP", ",", "list", ",", "element", ")", ";", "}" ]

[ "Removes", "the", "first", "element", "that", "is", "referentially", "equal", "to", "the", "supplied", "element", "(", "<code", ">", "list", "[", "idx", "]", "==", "element<", "/", "code", ">", ")", ".", "The", "elements", "after", "the", "removed", "element", "will", "be", "slid", "down", "the", "array", "one", "spot", "to", "fill", "the", "place", "of", "the", "removed", "element", "." ]

[ "@", "Override", "public", "final", "boolean", "isValid", "(", "final", "Object", "pvalue", ",", "final", "ConstraintValidatorContext", "pcontext", ")", "{", "final", "String", "valueAsString", "=", "Objects", ".", "toString", "(", "pvalue", ",", "null", ")", ";", "if", "(", "StringUtils", ".", "isEmpty", "(", "valueAsString", ")", ")", "{", "return", "true", ";", "}", "if", "(", "!", "StringUtils", ".", "isNumeric", "(", "valueAsString", ")", ")", "{", "// EAN must be numeric, but that's handled by digits annotation", "return", "true", ";", "}", "if", "(", "valueAsString", ".", "length", "(", ")", "!=", "Gtin8Validator", ".", "GTIN8_LENGTH", "&&", "valueAsString", ".", "length", "(", ")", "!=", "Gtin13Validator", ".", "GTIN13_LENGTH", ")", "{", "// EAN size is wrong, but that's handled by alternate size annotation", "return", "true", ";", "}", "// calculate and check checksum (GTIN/EAN)", "return", "CHECK_GTIN", ".", "isValid", "(", "valueAsString", ")", ";", "}" ]

[ "{", "@inheritDoc", "}", "check", "if", "given", "string", "is", "a", "valid", "gtin", "." ]

[ "public", "int", "keyOf", "(", "final", "double", "value", ")", "{", "final", "int", "[", "]", "foundKey", "=", "new", "int", "[", "1", "]", ";", "boolean", "notFound", "=", "forEachPair", "(", "new", "IntDoubleProcedure", "(", ")", "{", "public", "boolean", "apply", "(", "int", "iterKey", ",", "double", "iterValue", ")", "{", "boolean", "found", "=", "value", "==", "iterValue", ";", "if", "(", "found", ")", "foundKey", "[", "0", "]", "=", "iterKey", ";", "return", "!", "found", ";", "}", "}", ")", ";", "if", "(", "notFound", ")", "return", "Integer", ".", "MIN_VALUE", ";", "return", "foundKey", "[", "0", "]", ";", "}" ]

[ "Returns", "the", "first", "key", "the", "given", "value", "is", "associated", "with", ".", "It", "is", "often", "a", "good", "idea", "to", "first", "check", "with", "{", "@link", "#containsValue", "(", "double", ")", "}", "whether", "there", "exists", "an", "association", "from", "a", "key", "to", "this", "value", ".", "Search", "order", "is", "guaranteed", "to", "be", "<i", ">", "identical<", "/", "i", ">", "to", "the", "order", "used", "by", "method", "{", "@link", "#forEachKey", "(", "IntProcedure", ")", "}", "." ]

[ "public", "Janbanery", "connectAndKeepUsing", "(", "String", "user", ",", "String", "password", ")", "throws", "ServerCommunicationException", "{", "DefaultConfiguration", "conf", "=", "new", "DefaultConfiguration", "(", "user", ",", "password", ")", ";", "RestClient", "restClient", "=", "getRestClient", "(", "conf", ")", ";", "return", "new", "Janbanery", "(", "conf", ",", "restClient", ")", ";", "}" ]

[ "This", "method", "will", "connect", "to", "kanbanery", "via", "basic", "user", "/", "pass", "authentication", "<strong", ">", "and", "will", "keep", "using", "it", "until", "forced", "to", "switch", "modes!<", "/", "strong", ">", ".", "This", "method", "is", "not", "encouraged", "you", "should", "use", "{", "@link", "JanbaneryFactory#connectUsing", "(", "String", "String", ")", "}", "and", "allow", "Janbanery", "to", "switch", "to", "apiKey", "mode", "as", "soon", "as", "it", "load", "s", "up", "to", "increase", "security", "over", "the", "wire", "." ]

[ "public", "Object", "newProxy", "(", "ClassLoader", "classLoader", ",", "Class", "<", "?", ">", "...", "interfaces", ")", "{", "return", "Proxy", ".", "newProxyInstance", "(", "classLoader", ",", "interfaces", ",", "this", ")", ";", "}" ]

[ "Create", "a", "proxy", "using", "given", "classloader", "and", "interfaces" ]

[ "private", "void", "addEntry", "(", "final", "Path", "pathToFile", ",", "final", "URL", "resource", ")", "throws", "IOException", "{", "final", "Path", "parent", "=", "pathToFile", ".", "getParent", "(", ")", ";", "if", "(", "parent", "!=", "null", ")", "{", "addFolder", "(", "parent", ")", ";", "}", "try", "(", "InputStream", "inputStream", "=", "resource", ".", "openStream", "(", ")", ")", "{", "Files", ".", "copy", "(", "inputStream", ",", "pathToFile", ")", ";", "}", "}" ]

[ "Creates", "an", "entry", "under", "the", "specifeid", "path", "with", "the", "content", "from", "the", "provided", "resource", "." ]

[ "public", "static", "double", "quadraticEuclidean", "(", "double", "[", "]", "v1", ",", "double", "[", "]", "v2", ")", "{", "final", "double", "d1", "=", "v1", "[", "0", "]", "-", "v2", "[", "0", "]", ",", "d2", "=", "v1", "[", "1", "]", "-", "v2", "[", "1", "]", ";", "return", "(", "d1", "*", "d1", ")", "+", "(", "d2", "*", "d2", ")", ";", "}" ]

[ "Squared", "euclidean", "distance", ".", "2d", "." ]

[ "public", "static", "Object", "createObject", "(", "Class", "classObject", ",", "Object", "[", "]", "params", ")", "throws", "Exception", "{", "Constructor", "[", "]", "constructors", "=", "classObject", ".", "getConstructors", "(", ")", ";", "Object", "object", "=", "null", ";", "for", "(", "int", "counter", "=", "0", ";", "counter", "<", "constructors", ".", "length", ";", "counter", "++", ")", "{", "try", "{", "object", "=", "constructors", "[", "counter", "]", ".", "newInstance", "(", "params", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "if", "(", "e", "instanceof", "InvocationTargetException", ")", "(", "(", "InvocationTargetException", ")", "e", ")", ".", "getTargetException", "(", ")", ".", "printStackTrace", "(", ")", ";", "// do nothing, try the next constructor\r", "}", "}", "if", "(", "object", "==", "null", ")", "throw", "new", "InstantiationException", "(", ")", ";", "return", "object", ";", "}" ]

[ "Instantaite", "an", "Object", "instance", "requires", "a", "constractor", "with", "parameters" ]

[ "protected", "MultipartParsingResult", "parseRequest", "(", "ResourceRequest", "request", ")", "throws", "MultipartException", "{", "String", "encoding", "=", "determineEncoding", "(", "request", ")", ";", "FileUpload", "fileUpload", "=", "prepareFileUpload", "(", "encoding", ")", ";", "try", "{", "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "List", "<", "FileItem", ">", "fileItems", "=", "(", "(", "Portlet2FileUpload", ")", "fileUpload", ")", ".", "parseRequest", "(", "request", ")", ";", "return", "parseFileItems", "(", "fileItems", ",", "encoding", ")", ";", "}", "catch", "(", "FileUploadBase", ".", "SizeLimitExceededException", "ex", ")", "{", "throw", "new", "MaxUploadSizeExceededException", "(", "fileUpload", ".", "getSizeMax", "(", ")", ",", "ex", ")", ";", "}", "catch", "(", "FileUploadException", "ex", ")", "{", "throw", "new", "MultipartException", "(", "\"Could not parse multipart portlet request\"", ",", "ex", ")", ";", "}", "}" ]

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

[ "public", "String", "readString", "(", "HKey", "hk", ",", "String", "key", ",", "String", "valueName", ",", "String", "charsetName", ")", "throws", "RegistryException", "{", "try", "{", "return", "ReflectedMethods", ".", "readString", "(", "hk", ".", "root", "(", ")", ",", "hk", ".", "hex", "(", ")", ",", "key", ",", "valueName", ",", "charsetName", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "RegistryException", "(", "\"Cannot read \"", "+", "valueName", "+", "\" value from key \"", "+", "key", ",", "e", ")", ";", "}", "}" ]

[ "Read", "a", "value", "from", "key", "and", "value", "name" ]

[ "public", "static", "MozuUrl", "getCouponSetsUrl", "(", "String", "filter", ",", "Boolean", "includeCounts", ",", "Integer", "pageSize", ",", "String", "responseFields", ",", "String", "sortBy", ",", "Integer", "startIndex", ")", "{", "UrlFormatter", "formatter", "=", "new", "UrlFormatter", "(", "\"/api/commerce/catalog/admin/couponsets/?startIndex={startIndex}&pageSize={pageSize}&sortBy={sortBy}&filter={filter}&includeCounts={includeCounts}&responseFields={responseFields}\"", ")", ";", "formatter", ".", "formatUrl", "(", "\"filter\"", ",", "filter", ")", ";", "formatter", ".", "formatUrl", "(", "\"includeCounts\"", ",", "includeCounts", ")", ";", "formatter", ".", "formatUrl", "(", "\"pageSize\"", ",", "pageSize", ")", ";", "formatter", ".", "formatUrl", "(", "\"responseFields\"", ",", "responseFields", ")", ";", "formatter", ".", "formatUrl", "(", "\"sortBy\"", ",", "sortBy", ")", ";", "formatter", ".", "formatUrl", "(", "\"startIndex\"", ",", "startIndex", ")", ";", "return", "new", "MozuUrl", "(", "formatter", ".", "getResourceUrl", "(", ")", ",", "MozuUrl", ".", "UrlLocation", ".", "TENANT_POD", ")", ";", "}" ]

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

[ "static", "List", "<", "HpackHeader", ">", "createHeaders", "(", "int", "numHeaders", ",", "int", "nameLength", ",", "int", "valueLength", ",", "boolean", "limitToAscii", ")", "{", "List", "<", "HpackHeader", ">", "hpackHeaders", "=", "new", "ArrayList", "<", "HpackHeader", ">", "(", "numHeaders", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "numHeaders", ";", "++", "i", ")", "{", "byte", "[", "]", "name", "=", "randomBytes", "(", "new", "byte", "[", "nameLength", "]", ",", "limitToAscii", ")", ";", "byte", "[", "]", "value", "=", "randomBytes", "(", "new", "byte", "[", "valueLength", "]", ",", "limitToAscii", ")", ";", "hpackHeaders", ".", "add", "(", "new", "HpackHeader", "(", "name", ",", "value", ")", ")", ";", "}", "return", "hpackHeaders", ";", "}" ]

[ "Creates", "a", "number", "of", "random", "headers", "with", "the", "given", "name", "/", "value", "lengths", "." ]

[ "public", "static", "Point", "layerToScreen", "(", "Layer", "layer", ",", "float", "x", ",", "float", "y", ")", "{", "Point", "into", "=", "new", "Point", "(", "x", ",", "y", ")", ";", "return", "layerToScreen", "(", "layer", ",", "into", ",", "into", ")", ";", "}" ]

[ "Converts", "the", "supplied", "point", "from", "coordinates", "relative", "to", "the", "specified", "layer", "to", "screen", "coordinates", "." ]

[ "private", "Map", "<", "String", ",", "VariantSet", ">", "getVariants", "(", "ResourceBrowser", "rsBrowser", ",", "String", "rootDir", ",", "String", "defaultSkinName", ",", "String", "defaultLocaleName", ",", "boolean", "mappingSkinLocale", ")", "{", "Set", "<", "String", ">", "paths", "=", "rsBrowser", ".", "getResourceNames", "(", "rootDir", ")", ";", "Set", "<", "String", ">", "skinNames", "=", "new", "HashSet", "<>", "(", ")", ";", "Set", "<", "String", ">", "localeVariants", "=", "new", "HashSet", "<>", "(", ")", ";", "for", "(", "Iterator", "<", "String", ">", "itPath", "=", "paths", ".", "iterator", "(", ")", ";", "itPath", ".", "hasNext", "(", ")", ";", ")", "{", "String", "path", "=", "rootDir", "+", "itPath", ".", "next", "(", ")", ";", "if", "(", "rsBrowser", ".", "isDirectory", "(", "path", ")", ")", "{", "String", "dirName", "=", "PathNormalizer", ".", "getPathName", "(", "path", ")", ";", "if", "(", "mappingSkinLocale", ")", "{", "skinNames", ".", "add", "(", "dirName", ")", ";", "// check if there are locale variants for this skin,", "// and update the localeVariants if needed", "updateLocaleVariants", "(", "rsBrowser", ",", "path", ",", "localeVariants", ")", ";", "}", "else", "{", "if", "(", "LocaleUtils", ".", "LOCALE_SUFFIXES", ".", "contains", "(", "dirName", ")", ")", "{", "localeVariants", ".", "add", "(", "dirName", ")", ";", "// check if there are skin variants for this locales,", "// and update the skinVariants if needed", "updateSkinVariants", "(", "rsBrowser", ",", "path", ",", "skinNames", ")", ";", "}", "}", "}", "}", "// Initialize the variant mapping for the skin root directory", "return", "getVariants", "(", "defaultSkinName", ",", "skinNames", ",", "defaultLocaleName", ",", "localeVariants", ")", ";", "}" ]

[ "Initialize", "the", "skinMapping", "from", "the", "parent", "path" ]

[ "public", "static", "void", "debugTraceWsByteBuffer", "(", "Object", "_this", ",", "TraceComponent", "_tc", ",", "WsByteBuffer", "buffer", ",", "int", "amount", ",", "String", "comment", ")", "{", "byte", "[", "]", "data", "=", "null", ";", "int", "start", ";", "int", "count", "=", "amount", ";", "if", "(", "count", ">", "buffer", ".", "remaining", "(", ")", ")", "count", "=", "buffer", ".", "remaining", "(", ")", ";", "if", "(", "buffer", ".", "hasArray", "(", ")", ")", "{", "data", "=", "buffer", ".", "array", "(", ")", ";", "start", "=", "buffer", ".", "arrayOffset", "(", ")", "+", "buffer", ".", "position", "(", ")", ";", ";", "}", "else", "{", "data", "=", "new", "byte", "[", "count", "]", ";", "int", "pos", "=", "buffer", ".", "position", "(", ")", ";", "buffer", ".", "get", "(", "data", ")", ";", "buffer", ".", "position", "(", "pos", ")", ";", "start", "=", "0", ";", "}", "StringBuffer", "sb", "=", "new", "StringBuffer", "(", "comment", ")", ";", "sb", ".", "append", "(", "\"\\nbuffer hashcode: \"", ")", ";", "sb", ".", "append", "(", "buffer", ".", "hashCode", "(", ")", ")", ";", "sb", ".", "append", "(", "\"\\nbuffer position: \"", ")", ";", "sb", ".", "append", "(", "buffer", ".", "position", "(", ")", ")", ";", "sb", ".", "append", "(", "\"\\nbuffer remaining: \"", ")", ";", "sb", ".", "append", "(", "buffer", ".", "remaining", "(", ")", ")", ";", "sb", ".", "append", "(", "\"\\n\"", ")", ";", "SibTr", ".", "debug", "(", "_this", ",", "_tc", ",", "sb", ".", "toString", "(", ")", ")", ";", "if", "(", "count", ">", "0", ")", "SibTr", ".", "bytes", "(", "_this", ",", "_tc", ",", "data", ",", "start", ",", "count", ",", "\"First \"", "+", "count", "+", "\" bytes of buffer data:\"", ")", ";", "}" ]

[ "Produces", "a", "debug", "trace", "entry", "for", "a", "WsByteBuffer", ".", "This", "should", "be", "used", "as", "follows", ":", "<code", ">", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "()", "&&", "tc", ".", "isDebugEnabled", "()", ")", "debugTraceWsByteBuffer", "(", "...", ")", ";", "<", "/", "code", ">" ]

[ "public", "Observable", "<", "List", "<", "IntentsSuggestionExample", ">", ">", "getIntentSuggestionsAsync", "(", "UUID", "appId", ",", "String", "versionId", ",", "UUID", "intentId", ",", "GetIntentSuggestionsOptionalParameter", "getIntentSuggestionsOptionalParameter", ")", "{", "return", "getIntentSuggestionsWithServiceResponseAsync", "(", "appId", ",", "versionId", ",", "intentId", ",", "getIntentSuggestionsOptionalParameter", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "List", "<", "IntentsSuggestionExample", ">", ">", ",", "List", "<", "IntentsSuggestionExample", ">", ">", "(", ")", "{", "@", "Override", "public", "List", "<", "IntentsSuggestionExample", ">", "call", "(", "ServiceResponse", "<", "List", "<", "IntentsSuggestionExample", ">", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Suggests", "examples", "that", "would", "improve", "the", "accuracy", "of", "the", "intent", "model", "." ]

[ "public", "T", "modifyModule", "(", "final", "String", "moduleName", ",", "final", "String", "slot", ",", "final", "byte", "[", "]", "existingHash", ",", "final", "byte", "[", "]", "newHash", ")", "{", "final", "ContentItem", "item", "=", "createModuleItem", "(", "moduleName", ",", "slot", ",", "newHash", ")", ";", "addContentModification", "(", "createContentModification", "(", "item", ",", "ModificationType", ".", "MODIFY", ",", "existingHash", ")", ")", ";", "return", "returnThis", "(", ")", ";", "}" ]

[ "Modify", "a", "module", "." ]

[ "public", "static", "PlotCanvas", "screeplot", "(", "PCA", "pca", ")", "{", "int", "n", "=", "pca", ".", "getVarianceProportion", "(", ")", ".", "length", ";", "double", "[", "]", "lowerBound", "=", "{", "0", ",", "0.0", "}", ";", "double", "[", "]", "upperBound", "=", "{", "n", "+", "1", ",", "1.0", "}", ";", "PlotCanvas", "canvas", "=", "new", "PlotCanvas", "(", "lowerBound", ",", "upperBound", ",", "false", ")", ";", "canvas", ".", "setAxisLabels", "(", "\"Principal Component\"", ",", "\"Proportion of Variance\"", ")", ";", "String", "[", "]", "labels", "=", "new", "String", "[", "n", "]", ";", "double", "[", "]", "x", "=", "new", "double", "[", "n", "]", ";", "double", "[", "]", "[", "]", "data", "=", "new", "double", "[", "n", "]", "[", "2", "]", ";", "double", "[", "]", "[", "]", "data2", "=", "new", "double", "[", "n", "]", "[", "2", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "n", ";", "i", "++", ")", "{", "labels", "[", "i", "]", "=", "\"PC\"", "+", "(", "i", "+", "1", ")", ";", "x", "[", "i", "]", "=", "i", "+", "1", ";", "data", "[", "i", "]", "[", "0", "]", "=", "x", "[", "i", "]", ";", "data", "[", "i", "]", "[", "1", "]", "=", "pca", ".", "getVarianceProportion", "(", ")", "[", "i", "]", ";", "data2", "[", "i", "]", "[", "0", "]", "=", "x", "[", "i", "]", ";", "data2", "[", "i", "]", "[", "1", "]", "=", "pca", ".", "getCumulativeVarianceProportion", "(", ")", "[", "i", "]", ";", "}", "LinePlot", "plot", "=", "new", "LinePlot", "(", "data", ")", ";", "plot", ".", "setID", "(", "\"Variance\"", ")", ";", "plot", ".", "setColor", "(", "Color", ".", "RED", ")", ";", "plot", ".", "setLegend", "(", "'", "'", ")", ";", "canvas", ".", "add", "(", "plot", ")", ";", "canvas", ".", "getAxis", "(", "0", ")", ".", "addLabel", "(", "labels", ",", "x", ")", ";", "LinePlot", "plot2", "=", "new", "LinePlot", "(", "data2", ")", ";", "plot2", ".", "setID", "(", "\"Cumulative Variance\"", ")", ";", "plot2", ".", "setColor", "(", "Color", ".", "BLUE", ")", ";", "plot2", ".", "setLegend", "(", "'", "'", ")", ";", "canvas", ".", "add", "(", "plot2", ")", ";", "return", "canvas", ";", "}" ]

[ "Create", "a", "scree", "plot", "for", "PCA", "." ]

[ "static", "private", "StringBuilder", "determineType", "(", "String", "name", ",", "Object", "o", ")", "{", "String", "value", "=", "null", ";", "if", "(", "o", "instanceof", "String", "||", "o", "instanceof", "StringBuffer", "||", "o", "instanceof", "java", ".", "nio", ".", "CharBuffer", "||", "o", "instanceof", "Integer", "||", "o", "instanceof", "Long", "||", "o", "instanceof", "Byte", "||", "o", "instanceof", "Double", "||", "o", "instanceof", "Float", "||", "o", "instanceof", "Short", "||", "o", "instanceof", "BigInteger", "||", "o", "instanceof", "java", ".", "math", ".", "BigDecimal", ")", "{", "value", "=", "o", ".", "toString", "(", ")", ";", "}", "else", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"Skipping class: \"", "+", "o", ".", "getClass", "(", ")", ")", ";", "}", "return", "null", ";", "}", "// type=\"class\" name=\"o\"", "StringBuilder", "buffer", "=", "new", "StringBuilder", "(", "48", ")", ";", "buffer", ".", "append", "(", "name", ")", ";", "buffer", ".", "append", "(", "\"type=\\\"\"", ")", ";", "// charbuffer is abstract so we might get HeapCharBuffer here, force it", "// to the generic layer in the XML output", "if", "(", "o", "instanceof", "java", ".", "nio", ".", "CharBuffer", ")", "{", "buffer", ".", "append", "(", "\"java.nio.CharBuffer\"", ")", ";", "}", "else", "{", "buffer", ".", "append", "(", "o", ".", "getClass", "(", ")", ".", "getName", "(", ")", ")", ";", "}", "buffer", ".", "append", "(", "\"\\\" \"", ")", ";", "buffer", ".", "append", "(", "name", ")", ";", "buffer", ".", "append", "(", "\"=\\\"\"", ")", ";", "buffer", ".", "append", "(", "value", ")", ";", "buffer", ".", "append", "(", "\"\\\"\"", ")", ";", "return", "buffer", ";", "}" ]

[ "Determine", "the", "type", "of", "the", "Object", "passed", "in", "and", "add", "the", "XML", "format", "for", "the", "result", "." ]

[ "public", "Matrix4f", "lookAt", "(", "float", "eyeX", ",", "float", "eyeY", ",", "float", "eyeZ", ",", "float", "centerX", ",", "float", "centerY", ",", "float", "centerZ", ",", "float", "upX", ",", "float", "upY", ",", "float", "upZ", ",", "Matrix4f", "dest", ")", "{", "if", "(", "(", "properties", "&", "PROPERTY_IDENTITY", ")", "!=", "0", ")", "return", "dest", ".", "setLookAt", "(", "eyeX", ",", "eyeY", ",", "eyeZ", ",", "centerX", ",", "centerY", ",", "centerZ", ",", "upX", ",", "upY", ",", "upZ", ")", ";", "else", "if", "(", "(", "properties", "&", "PROPERTY_PERSPECTIVE", ")", "!=", "0", ")", "return", "lookAtPerspective", "(", "eyeX", ",", "eyeY", ",", "eyeZ", ",", "centerX", ",", "centerY", ",", "centerZ", ",", "upX", ",", "upY", ",", "upZ", ",", "dest", ")", ";", "return", "lookAtGeneric", "(", "eyeX", ",", "eyeY", ",", "eyeZ", ",", "centerX", ",", "centerY", ",", "centerZ", ",", "upX", ",", "upY", ",", "upZ", ",", "dest", ")", ";", "}" ]

[ "Apply", "a", "lookat", "transformation", "to", "this", "matrix", "for", "a", "right", "-", "handed", "coordinate", "system", "that", "aligns", "<code", ">", "-", "z<", "/", "code", ">", "with", "<code", ">", "center", "-", "eye<", "/", "code", ">", "and", "store", "the", "result", "in", "<code", ">", "dest<", "/", "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", "lookat", "transformation", "without", "post", "-", "multiplying", "it", "use", "{", "@link", "#setLookAt", "(", "float", "float", "float", "float", "float", "float", "float", "float", "float", ")", "setLookAt", "()", "}", "." ]

[ "@", "Pure", "public", "static", "GeodesicPosition", "L93_WSG84", "(", "double", "x", ",", "double", "y", ")", "{", "final", "Point2d", "ntfLambdaPhi", "=", "NTFLambert_NTFLambdaPhi", "(", "x", ",", "y", ",", "LAMBERT_93_N", ",", "LAMBERT_93_C", ",", "LAMBERT_93_XS", ",", "LAMBERT_93_YS", ")", ";", "return", "NTFLambdaPhi_WSG84", "(", "ntfLambdaPhi", ".", "getX", "(", ")", ",", "ntfLambdaPhi", ".", "getY", "(", ")", ")", ";", "}" ]

[ "This", "function", "convert", "France", "Lambert", "93", "coordinate", "to", "geographic", "WSG84", "Data", "." ]

[ "private", "static", "Serializable", "read", "(", "URLConnection", "connection", ",", "InputStream", "inputStream", ")", "throws", "IOException", ",", "ClassNotFoundException", "{", "InputStream", "input", "=", "inputStream", ";", "try", "{", "if", "(", "\"gzip\"", ".", "equals", "(", "connection", ".", "getContentEncoding", "(", ")", ")", ")", "{", "// si la taille du flux dépasse x Ko et que l'application a retourné un flux compressé\r", "// alors on le décompresse\r", "input", "=", "new", "GZIPInputStream", "(", "input", ")", ";", "}", "final", "String", "contentType", "=", "connection", ".", "getContentType", "(", ")", ";", "final", "TransportFormat", "transportFormat", ";", "if", "(", "contentType", "!=", "null", ")", "{", "if", "(", "contentType", ".", "startsWith", "(", "\"text/xml\"", ")", ")", "{", "transportFormat", "=", "TransportFormat", ".", "XML", ";", "}", "else", "if", "(", "contentType", ".", "startsWith", "(", "\"text/html\"", ")", ")", "{", "throw", "new", "IllegalStateException", "(", "\"Unexpected html content type, maybe not authentified\"", ")", ";", "}", "else", "{", "transportFormat", "=", "TransportFormat", ".", "SERIALIZED", ";", "}", "}", "else", "{", "transportFormat", "=", "TransportFormat", ".", "SERIALIZED", ";", "}", "return", "transportFormat", ".", "readSerializableFrom", "(", "input", ")", ";", "}", "finally", "{", "try", "{", "input", ".", "close", "(", ")", ";", "}", "finally", "{", "close", "(", "connection", ")", ";", "}", "}", "}" ]

[ "Lit", "l", "objet", "renvoyé", "dans", "le", "flux", "de", "réponse", "." ]

[ "protected", "void", "appendCopy", "(", "RoaringArray", "sa", ",", "int", "startingIndex", ",", "int", "end", ")", "{", "extendArray", "(", "end", "-", "startingIndex", ")", ";", "for", "(", "int", "i", "=", "startingIndex", ";", "i", "<", "end", ";", "++", "i", ")", "{", "this", ".", "keys", "[", "this", ".", "size", "]", "=", "sa", ".", "keys", "[", "i", "]", ";", "this", ".", "values", "[", "this", ".", "size", "]", "=", "sa", ".", "values", "[", "i", "]", ".", "clone", "(", ")", ";", "this", ".", "size", "++", ";", "}", "}" ]

[ "Append", "copies", "of", "the", "values", "from", "another", "array" ]

[ "public", "<", "H", ",", "R", ">", "T", "createKey", "(", "final", "H", "hashKey", ",", "final", "R", "rangeKey", ")", "{", "final", "T", "key", "=", "StandardBeanProperties", ".", "DeclaringReflect", ".", "<", "T", ">", "newInstance", "(", "targetType", ")", ";", "if", "(", "hashKey", "!=", "null", ")", "{", "final", "DynamoDBMapperFieldModel", "<", "T", ",", "H", ">", "hk", "=", "hashKey", "(", ")", ";", "hk", ".", "set", "(", "key", ",", "hashKey", ")", ";", "}", "if", "(", "rangeKey", "!=", "null", ")", "{", "final", "DynamoDBMapperFieldModel", "<", "T", ",", "R", ">", "rk", "=", "rangeKey", "(", ")", ";", "rk", ".", "set", "(", "key", ",", "rangeKey", ")", ";", "}", "return", "key", ";", "}" ]

[ "Creates", "a", "new", "object", "instance", "with", "the", "keys", "populated", "." ]

[ "public", "static", "String", "findMainClass", "(", "JarFile", "jarFile", ",", "String", "classesLocation", ")", "throws", "IOException", "{", "return", "doWithMainClasses", "(", "jarFile", ",", "classesLocation", ",", "new", "ClassNameCallback", "<", "String", ">", "(", ")", "{", "@", "Override", "public", "String", "doWith", "(", "String", "className", ")", "{", "return", "className", ";", "}", "}", ")", ";", "}" ]

[ "Find", "the", "main", "class", "in", "a", "given", "jar", "file", "." ]

[ "public", "static", "byte", "[", "]", "getBytesHttp", "(", "String", "pURL", ",", "int", "pTimeout", ")", "throws", "IOException", "{", "// Get the input stream from the url", "InputStream", "in", "=", "new", "BufferedInputStream", "(", "getInputStreamHttp", "(", "pURL", ",", "pTimeout", ")", ",", "BUF_SIZE", "*", "2", ")", ";", "// Get all the bytes in loop", "ByteArrayOutputStream", "bytes", "=", "new", "ByteArrayOutputStream", "(", ")", ";", "int", "count", ";", "byte", "[", "]", "buffer", "=", "new", "byte", "[", "BUF_SIZE", "]", ";", "try", "{", "while", "(", "(", "count", "=", "in", ".", "read", "(", "buffer", ")", ")", "!=", "-", "1", ")", "{", "// NOTE: According to the J2SE API doc, read(byte[]) will read", "// at least 1 byte, or return -1, if end-of-file is reached.", "bytes", ".", "write", "(", "buffer", ",", "0", ",", "count", ")", ";", "}", "}", "finally", "{", "// Close the buffer", "in", ".", "close", "(", ")", ";", "}", "return", "bytes", ".", "toByteArray", "(", ")", ";", "}" ]

[ "Gets", "the", "content", "from", "a", "given", "URL", "with", "the", "given", "timeout", ".", "The", "timeout", "must", "be", ">", "0", ".", "A", "timeout", "of", "zero", "is", "interpreted", "as", "an", "infinite", "timeout", ".", "Supports", "basic", "HTTP", "authentication", "using", "a", "URL", "string", "similar", "to", "most", "browsers", ".", "<P", "/", ">", "<SMALL", ">", "Implementation", "note", ":", "If", "the", "timeout", "parameter", "is", "greater", "than", "0", "this", "method", "uses", "my", "own", "implementation", "of", "java", ".", "net", ".", "HttpURLConnection", "that", "uses", "plain", "sockets", "to", "create", "an", "HTTP", "connection", "to", "the", "given", "URL", ".", "The", "{", "@code", "read", "}", "methods", "called", "on", "the", "returned", "InputStream", "will", "block", "only", "for", "the", "specified", "timeout", ".", "If", "the", "timeout", "expires", "a", "java", ".", "io", ".", "InterruptedIOException", "is", "raised", ".", "<BR", "/", ">", "<", "/", "SMALL", ">" ]

[ "private", "static", "void", "decodeOtherProperties", "(", "JmsDestination", "newDest", ",", "byte", "[", "]", "msgForm", ",", "int", "offset", ")", "throws", "JMSException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "tc", ",", "\"decodeOtherProperties\"", ",", "new", "Object", "[", "]", "{", "newDest", ",", "msgForm", ",", "offset", "}", ")", ";", "PropertyInputStream", "stream", "=", "new", "PropertyInputStream", "(", "msgForm", ",", "offset", ")", ";", "while", "(", "stream", ".", "hasMore", "(", ")", ")", "{", "String", "shortName", "=", "stream", ".", "readShortName", "(", ")", ";", "String", "longName", "=", "reverseMap", ".", "get", "(", "shortName", ")", ";", "if", "(", "longName", "!=", "null", ")", "{", "PropertyEntry", "propEntry", "=", "propertyMap", ".", "get", "(", "longName", ")", ";", "// This can't be null, as we just got the name from the reverseMap!", "Object", "propValue", "=", "propEntry", ".", "getPropertyCoder", "(", ")", ".", "decodeProperty", "(", "stream", ")", ";", "setProperty", "(", "newDest", ",", "longName", ",", "propEntry", ".", "getIntValue", "(", ")", ",", "propValue", ")", ";", "}", "else", "{", "// If there is no mapping for the short name, then the property is not known.", "// The most likely situation is that we have been sent a property for a newer release.", "//", "throw", "(", "JMSException", ")", "JmsErrorUtils", ".", "newThrowable", "(", "JMSException", ".", "class", ",", "\"UNKNOWN_PROPERTY_CWSIA0363\"", ",", "new", "Object", "[", "]", "{", "shortName", "}", ",", "null", ",", "\"MsgDestEncodingUtilsImpl.decodeOtherProperties#1\"", ",", "null", ",", "tc", ")", ";", "}", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"decodeOtherProperties\"", ")", ";", "}" ]

[ "decodeOtherProperties", "Decode", "the", "more", "interesting", "JmsDestination", "properties", "which", "may", "or", "may", "not", "be", "included", ":", "Queue", "/", "Topic", "name", "TopicSpace", "ReadAhead", "Cluster", "properties" ]

[ "public", "static", "void", "sendBlockData", "(", "Chunk", "chunk", ",", "String", "identifier", ",", "ByteBuf", "data", ",", "EntityPlayerMP", "player", ")", "{", "MalisisCore", ".", "network", ".", "sendTo", "(", "new", "Packet", "(", "chunk", ",", "identifier", ",", "data", ")", ",", "player", ")", ";", "}" ]

[ "Sends", "the", "data", "to", "the", "specified", "{", "@link", "EntityPlayerMP", "}", "." ]

[ "public", "synchronized", "void", "nameObject", "(", "String", "namePrefix", ",", "INameable", "object", ")", "{", "String", "name", "=", "namePrefix", "+", "Integer", ".", "toString", "(", "_nextValue", "++", ")", ";", "object", ".", "setObjectName", "(", "name", ")", ";", "}" ]

[ "This", "method", "will", "create", "a", "unique", "name", "for", "an", "INameable", "object", ".", "The", "name", "will", "be", "unque", "within", "the", "session", ".", "This", "will", "throw", "an", "IllegalStateException", "if", "INameable", ".", "setObjectName", "has", "previously", "been", "called", "on", "object", "." ]

[ "@", "SuppressWarnings", "(", "\"checkstyle:magicnumber\"", ")", "private", "static", "int", "read8ByteDoubleRecordValue", "(", "DBaseFileField", "field", ",", "int", "nrecord", ",", "int", "nfield", ",", "byte", "[", "]", "rawData", ",", "int", "rawOffset", ",", "OutputParameter", "<", "Double", ">", "value", ")", "throws", "IOException", "{", "final", "double", "rawNumber", "=", "EndianNumbers", ".", "toLEDouble", "(", "rawData", "[", "rawOffset", "]", ",", "rawData", "[", "rawOffset", "+", "1", "]", ",", "rawData", "[", "rawOffset", "+", "2", "]", ",", "rawData", "[", "rawOffset", "+", "3", "]", ",", "rawData", "[", "rawOffset", "+", "4", "]", ",", "rawData", "[", "rawOffset", "+", "5", "]", ",", "rawData", "[", "rawOffset", "+", "6", "]", ",", "rawData", "[", "rawOffset", "+", "7", "]", ")", ";", "try", "{", "value", ".", "set", "(", "new", "Double", "(", "rawNumber", ")", ")", ";", "return", "8", ";", "}", "catch", "(", "NumberFormatException", "exception", ")", "{", "throw", "new", "InvalidRawDataFormatException", "(", "nrecord", ",", "nfield", ",", "Double", ".", "toString", "(", "rawNumber", ")", ")", ";", "}", "}" ]

[ "Read", "a", "8", "BYTE", "DOUBLE", "record", "value", "." ]

[ "public", "static", "MchPayApp", "generateMchAppData", "(", "String", "prepay_id", ",", "String", "appId", ",", "String", "partnerid", ",", "String", "key", ")", "{", "Map", "<", "String", ",", "String", ">", "wx_map", "=", "new", "LinkedHashMap", "<", "String", ",", "String", ">", "(", ")", ";", "wx_map", ".", "put", "(", "\"appid\"", ",", "appId", ")", ";", "wx_map", ".", "put", "(", "\"partnerid\"", ",", "partnerid", ")", ";", "wx_map", ".", "put", "(", "\"prepayid\"", ",", "prepay_id", ")", ";", "wx_map", ".", "put", "(", "\"package\"", ",", "\"Sign=WXPay\"", ")", ";", "wx_map", ".", "put", "(", "\"noncestr\"", ",", "UUID", ".", "randomUUID", "(", ")", ".", "toString", "(", ")", ".", "replace", "(", "\"-\"", ",", "\"\"", ")", ")", ";", "wx_map", ".", "put", "(", "\"timestamp\"", ",", "System", ".", "currentTimeMillis", "(", ")", "/", "1000", "+", "\"\"", ")", ";", "String", "sign", "=", "SignatureUtil", ".", "generateSign", "(", "wx_map", ",", "key", ")", ";", "MchPayApp", "mchPayApp", "=", "new", "MchPayApp", "(", ")", ";", "mchPayApp", ".", "setAppid", "(", "appId", ")", ";", "mchPayApp", ".", "setPartnerid", "(", "partnerid", ")", ";", "mchPayApp", ".", "setPrepayid", "(", "prepay_id", ")", ";", "mchPayApp", ".", "setPackage_", "(", "wx_map", ".", "get", "(", "\"package\"", ")", ")", ";", "mchPayApp", ".", "setNoncestr", "(", "wx_map", ".", "get", "(", "\"noncestr\"", ")", ")", ";", "mchPayApp", ".", "setTimestamp", "(", "wx_map", ".", "get", "(", "\"timestamp\"", ")", ")", ";", "mchPayApp", ".", "setSign", "(", "sign", ")", ";", "return", "mchPayApp", ";", "}" ]

[ "(", "MCH", ")", "生成支付APP请求数据" ]

[ "public", "List", "<", "CaseStageInstance", ">", "internalGetCaseStages", "(", "CaseDefinition", "caseDef", ",", "String", "caseId", ",", "boolean", "activeOnly", ",", "QueryContext", "queryContext", ")", "{", "CorrelationKey", "correlationKey", "=", "correlationKeyFactory", ".", "newCorrelationKey", "(", "caseId", ")", ";", "Collection", "<", "org", ".", "jbpm", ".", "services", ".", "api", ".", "model", ".", "NodeInstanceDesc", ">", "nodes", "=", "runtimeDataService", ".", "getNodeInstancesByCorrelationKeyNodeType", "(", "correlationKey", ",", "Arrays", ".", "asList", "(", "ProcessInstance", ".", "STATE_ACTIVE", ")", ",", "Arrays", ".", "asList", "(", "\"DynamicNode\"", ")", ",", "queryContext", ")", ";", "Collection", "<", "Long", ">", "completedNodes", "=", "nodes", ".", "stream", "(", ")", ".", "filter", "(", "n", "->", "(", "(", "NodeInstanceDesc", ")", "n", ")", ".", "getType", "(", ")", "==", "1", ")", ".", "map", "(", "n", "->", "n", ".", "getId", "(", ")", ")", ".", "collect", "(", "toList", "(", ")", ")", ";", "Map", "<", "String", ",", "CaseStage", ">", "stagesByName", "=", "caseDef", ".", "getCaseStages", "(", ")", ".", "stream", "(", ")", ".", "collect", "(", "toMap", "(", "CaseStage", "::", "getId", ",", "c", "->", "c", ")", ")", ";", "Predicate", "<", "org", ".", "jbpm", ".", "services", ".", "api", ".", "model", ".", "NodeInstanceDesc", ">", "filterNodes", "=", "null", ";", "if", "(", "activeOnly", ")", "{", "filterNodes", "=", "n", "->", "(", "(", "NodeInstanceDesc", ")", "n", ")", ".", "getType", "(", ")", "==", "0", "&&", "!", "completedNodes", ".", "contains", "(", "(", "(", "NodeInstanceDesc", ")", "n", ")", ".", "getId", "(", ")", ")", ";", "}", "else", "{", "filterNodes", "=", "n", "->", "(", "(", "NodeInstanceDesc", ")", "n", ")", ".", "getType", "(", ")", "==", "0", ";", "}", "List", "<", "String", ">", "triggeredStages", "=", "new", "ArrayList", "<>", "(", ")", ";", "List", "<", "CaseStageInstance", ">", "stages", "=", "new", "ArrayList", "<>", "(", ")", ";", "nodes", ".", "stream", "(", ")", ".", "filter", "(", "filterNodes", ")", ".", "map", "(", "n", "->", "{", "StageStatus", "status", "=", "StageStatus", ".", "Active", ";", "if", "(", "completedNodes", ".", "contains", "(", "(", "(", "NodeInstanceDesc", ")", "n", ")", ".", "getId", "(", ")", ")", ")", "{", "status", "=", "StageStatus", ".", "Completed", ";", "}", "Collection", "<", "org", ".", "jbpm", ".", "services", ".", "api", ".", "model", ".", "NodeInstanceDesc", ">", "activeNodes", "=", "getActiveNodesForCaseAndStage", "(", "caseId", ",", "n", ".", "getNodeId", "(", ")", ",", "new", "QueryContext", "(", "0", ",", "100", ")", ")", ";", "return", "new", "CaseStageInstanceImpl", "(", "n", ".", "getNodeId", "(", ")", ",", "n", ".", "getName", "(", ")", ",", "stagesByName", ".", "get", "(", "n", ".", "getNodeId", "(", ")", ")", ".", "getAdHocFragments", "(", ")", ",", "activeNodes", ",", "status", ")", ";", "}", ")", ".", "forEach", "(", "csi", "->", "{", "stages", ".", "add", "(", "csi", ")", ";", "triggeredStages", ".", "add", "(", "csi", ".", "getName", "(", ")", ")", ";", "}", ")", ";", "if", "(", "!", "activeOnly", ")", "{", "// add other stages that are present in the definition ", "caseDef", ".", "getCaseStages", "(", ")", ".", "stream", "(", ")", ".", "filter", "(", "cs", "->", "!", "triggeredStages", ".", "contains", "(", "cs", ".", "getName", "(", ")", ")", ")", ".", "map", "(", "cs", "->", "new", "CaseStageInstanceImpl", "(", "cs", ".", "getId", "(", ")", ",", "cs", ".", "getName", "(", ")", ",", "cs", ".", "getAdHocFragments", "(", ")", ",", "Collections", ".", "emptyList", "(", ")", ",", "StageStatus", ".", "Available", ")", ")", ".", "forEach", "(", "csi", "->", "stages", ".", "add", "(", "csi", ")", ")", ";", "}", "return", "stages", ";", "}" ]

[ "/", "*", "Helper", "methods", "to", "parse", "process", "and", "extract", "case", "related", "information" ]

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

[ "Update", "the", "specified", "ExpressRouteCrossConnection", "." ]

[ "@", "Override", "@", "Deprecated", "public", "void", "forEachRemaining", "(", "java", ".", "util", ".", "function", ".", "Consumer", "<", "?", "super", "Triple", "<", "A", ",", "B", ",", "C", ">", ">", "action", ")", "{", "super", ".", "forEachRemaining", "(", "action", ")", ";", "}" ]

[ "It", "s", "preferred", "to", "call", "<code", ">", "forEachRemaining", "(", "Try", ".", "TriConsumer", ")", "<", "/", "code", ">", "to", "avoid", "the", "create", "the", "unnecessary", "<code", ">", "Triple<", "/", "code", ">", "Objects", "." ]

[ "public", "Path", "modifyPathToFinalDestination", "(", "Path", "path", ")", "throws", "IOException", "{", "String", "res", ";", "if", "(", "tempFileOriginator", ".", "equals", "(", "DEFAULT_FOUTPUTCOMMITTER_V1", ")", ")", "{", "res", "=", "parseHadoopOutputCommitter", "(", "path", ",", "true", ",", "hostNameScheme", ")", ";", "}", "else", "{", "res", "=", "extractNameFromTempPath", "(", "path", ",", "true", ",", "hostNameScheme", ")", ";", "}", "return", "new", "Path", "(", "hostNameScheme", ",", "res", ")", ";", "}" ]

[ "Accept", "temporary", "path", "and", "return", "a", "final", "destination", "path" ]

[ "@", "SuppressWarnings", "(", "\"SameParameterValue\"", ")", "public", "static", "long", "bytesToNumberLittleEndian", "(", "byte", "[", "]", "buffer", ",", "int", "start", ",", "int", "length", ")", "{", "long", "result", "=", "0", ";", "for", "(", "int", "index", "=", "start", "+", "length", "-", "1", ";", "index", ">=", "start", ";", "index", "--", ")", "{", "result", "=", "(", "result", "<<", "8", ")", "+", "unsign", "(", "buffer", "[", "index", "]", ")", ";", "}", "return", "result", ";", "}" ]

[ "Reconstructs", "a", "number", "that", "is", "represented", "by", "more", "than", "one", "byte", "in", "a", "network", "packet", "in", "little", "-", "endian", "order", "for", "the", "very", "few", "protocol", "values", "that", "are", "sent", "in", "this", "quirky", "way", "." ]

[ "public", "void", "enableConnector", "(", "String", "connectorClass", ",", "Properties", "connectorInitProperties", ")", "throws", "ConnectorInitException", "{", "ConnectorEntry", "connector", "=", "connectors", ".", "get", "(", "connectorClass", ")", ";", "if", "(", "connector", "!=", "null", ")", "connectors", ".", "get", "(", "connectorClass", ")", ".", "enableConnector", "(", "connectorInitProperties", ")", ";", "}" ]

[ "Makes", "enable", "connector", "with", "given", "class", "name", "if", "it", "registered", "and", "not", "already", "enabled", ".", "Non", "-", "existing", "or", "already", "enabled", "connectors", "be", "ignored" ]

[ "public", "static", "void", "requireDirectory", "(", "File", "destination", ")", "throws", "IOException", ",", "IllegalArgumentException", "{", "if", "(", "destination", ".", "isFile", "(", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "destination", "+", "\" exists and is a file, directory or path expected.\"", ")", ";", "}", "else", "if", "(", "!", "destination", ".", "exists", "(", ")", ")", "{", "destination", ".", "mkdirs", "(", ")", ";", "}", "if", "(", "!", "destination", ".", "canWrite", "(", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Can not write to destination \"", "+", "destination", ")", ";", "}", "}" ]

[ "Makes", "sure", "that", "the", "given", "{", "@link", "File", "}", "is", "either", "a", "writable", "directory", "or", "that", "it", "does", "not", "exist", "and", "a", "directory", "can", "be", "created", "at", "its", "path", ".", "<br", ">", "Will", "throw", "an", "exception", "if", "the", "given", "{", "@link", "File", "}", "is", "actually", "an", "existing", "file", "or", "the", "directory", "is", "not", "writable" ]

[ "public", "BitArray", "getRow", "(", "int", "y", ",", "BitArray", "row", ")", "{", "if", "(", "row", "==", "null", "||", "row", ".", "getSize", "(", ")", "<", "width", ")", "{", "row", "=", "new", "BitArray", "(", "width", ")", ";", "}", "else", "{", "row", ".", "clear", "(", ")", ";", "}", "int", "offset", "=", "y", "*", "rowSize", ";", "for", "(", "int", "x", "=", "0", ";", "x", "<", "rowSize", ";", "x", "++", ")", "{", "row", ".", "setBulk", "(", "x", "*", "32", ",", "bits", "[", "offset", "+", "x", "]", ")", ";", "}", "return", "row", ";", "}" ]

[ "A", "fast", "method", "to", "retrieve", "one", "row", "of", "data", "from", "the", "matrix", "as", "a", "BitArray", "." ]

[ "public", "static", "Pattern", "readColorPattern", "(", "final", "DataInput", "pStream", ")", "throws", "IOException", "{", "short", "type", "=", "pStream", ".", "readShort", "(", ")", ";", "Pattern", "pattern", ";", "Pattern", "fallback", "=", "readPattern", "(", "pStream", ")", ";", "if", "(", "type", "==", "1", ")", "{", "// TODO: This is foobar...", "// PixMap", "// ColorTable", "// PixData", "throw", "new", "IIOException", "(", "String", ".", "format", "(", "\"QuickDraw pattern type '0x%04x' not implemented (yet)\"", ",", "type", ")", ")", ";", "}", "else", "if", "(", "type", "==", "2", ")", "{", "Color", "color", "=", "readRGBColor", "(", "pStream", ")", ";", "pattern", "=", "new", "PixMapPattern", "(", "color", ",", "fallback", ")", ";", "}", "else", "{", "throw", "new", "IIOException", "(", "String", ".", "format", "(", "\"Unknown QuickDraw pattern type '0x%04x'\"", ",", "type", ")", ")", ";", "}", "return", "pattern", ";", "}" ]

[ "/", "*", "http", ":", "//", "developer", ".", "apple", ".", "com", "/", "DOCUMENTATION", "/", "mac", "/", "QuickDraw", "/", "QuickDraw", "-", "461", ".", "html#MARKER", "-", "9", "-", "243", "IF", "patType", "=", "ditherPat", "THEN", "PatType", ":", "word", ";", "{", "pattern", "type", "=", "2", "}", "Pat1Data", ":", "Pattern", ";", "{", "old", "pattern", "data", "}", "RGB", ":", "RGBColor", ";", "{", "desired", "RGB", "for", "pattern", "}", "ELSE", "PatType", ":", "word", ";", "{", "pattern", "type", "=", "1", "}", "Pat1Data", ":", "Pattern", ";", "{", "old", "pattern", "data", "}", "PixMap", ":", "PixMap", ";", "ColorTable", ":", "ColorTable", ";", "PixData", ":", "PixData", ";", "END", ";" ]

[ "public", "Shape", "createArrowLeft", "(", "final", "double", "x", ",", "final", "double", "y", ",", "final", "double", "w", ",", "final", "double", "h", ")", "{", "path", ".", "reset", "(", ")", ";", "path", ".", "moveTo", "(", "x", "+", "w", ",", "y", ")", ";", "path", ".", "lineTo", "(", "x", ",", "y", "+", "h", "/", "2.0", ")", ";", "path", ".", "lineTo", "(", "x", "+", "w", ",", "y", "+", "h", ")", ";", "path", ".", "closePath", "(", ")", ";", "return", "path", ";", "}" ]

[ "Return", "a", "path", "for", "an", "arrow", "pointing", "to", "the", "left", "." ]

[ "public", "static", "EJBContainer", "createEJBContainer", "(", "Map", "<", "?", ",", "?", ">", "properties", ")", "throws", "EJBException", "{", "for", "(", "EJBContainerProvider", "factory", ":", "factories", ")", "{", "EJBContainer", "container", "=", "factory", ".", "createEJBContainer", "(", "properties", ")", ";", "if", "(", "container", "!=", "null", ")", "return", "container", ";", "}", "throw", "new", "EJBException", "(", "\"Unable to instantiate container with factories \"", "+", "factories", ")", ";", "}" ]

[ "Create", "and", "initialize", "an", "embeddable", "EJB", "container", "with", "an", "set", "of", "configuration", "properties", "and", "names", "of", "modules", "to", "be", "initialized", "." ]

[ "public", "void", "openPageOrWarn", "(", "String", "link", ",", "String", "target", ")", "{", "openPageOrWarn", "(", "link", ",", "target", ",", "CmsVaadinUtils", ".", "getMessageText", "(", "org", ".", "opencms", ".", "ui", ".", "Messages", ".", "GUI_POPUP_BLOCKED_0", ")", ")", ";", "}" ]

[ "Tries", "to", "open", "a", "new", "browser", "window", "and", "shows", "a", "warning", "if", "opening", "the", "window", "fails", "(", "usually", "because", "of", "popup", "blockers", ")", ".", "<p", ">" ]

[ "public", "Team", "kickPlayer", "(", "long", "summonerId", ",", "TeamId", "teamId", ")", "{", "return", "client", ".", "sendRpcAndWait", "(", "SERVICE", ",", "\"kickPlayer\"", ",", "summonerId", ",", "teamId", ")", ";", "}" ]

[ "Kick", "a", "player", "from", "the", "target", "team" ]

[ "public", "static", "OptionDialog", "showOptionDialog", "(", "Stage", "stage", ",", "String", "title", ",", "String", "text", ",", "OptionDialogType", "type", ",", "OptionDialogListener", "listener", ")", "{", "OptionDialog", "dialog", "=", "new", "OptionDialog", "(", "title", ",", "text", ",", "type", ",", "listener", ")", ";", "stage", ".", "addActor", "(", "dialog", ".", "fadeIn", "(", ")", ")", ";", "return", "dialog", ";", "}" ]

[ "Dialog", "with", "text", "and", "buttons", "like", "Yes", "No", "Cancel", "." ]

[ "private", "boolean", "matchPreservesCase", "(", "List", "<", "Match", ">", "suggestionMatches", ",", "String", "msg", ")", "{", "if", "(", "suggestionMatches", "!=", "null", "&&", "!", "suggestionMatches", ".", "isEmpty", "(", ")", ")", "{", "//PatternRule rule = (PatternRule) this.rule;", "int", "sugStart", "=", "msg", ".", "indexOf", "(", "SUGGESTION_START_TAG", ")", "+", "SUGGESTION_START_TAG", ".", "length", "(", ")", ";", "for", "(", "Match", "sMatch", ":", "suggestionMatches", ")", "{", "if", "(", "!", "sMatch", ".", "isInMessageOnly", "(", ")", "&&", "sMatch", ".", "convertsCase", "(", ")", "&&", "msg", ".", "charAt", "(", "sugStart", ")", "==", "'", "'", ")", "{", "return", "false", ";", "}", "}", "}", "return", "true", ";", "}" ]

[ "Checks", "if", "the", "suggestion", "starts", "with", "a", "match", "that", "is", "supposed", "to", "preserve", "case", ".", "If", "it", "does", "not", "perform", "the", "default", "conversion", "to", "uppercase", "." ]

[ "public", "OvhRtmRaidVolume", "serviceName_statistics_raid_unit_volume_volume_GET", "(", "String", "serviceName", ",", "String", "unit", ",", "String", "volume", ")", "throws", "IOException", "{", "String", "qPath", "=", "\"/dedicated/server/{serviceName}/statistics/raid/{unit}/volume/{volume}\"", ";", "StringBuilder", "sb", "=", "path", "(", "qPath", ",", "serviceName", ",", "unit", ",", "volume", ")", ";", "String", "resp", "=", "exec", "(", "qPath", ",", "\"GET\"", ",", "sb", ".", "toString", "(", ")", ",", "null", ")", ";", "return", "convertTo", "(", "resp", ",", "OvhRtmRaidVolume", ".", "class", ")", ";", "}" ]

[ "Get", "this", "object", "properties" ]

[ "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "public", "static", "<", "E", ">", "E", "createRecord", "(", "Class", "<", "E", ">", "type", ",", "Schema", "schema", ")", "{", "// Don't instantiate SpecificRecords or interfaces.", "if", "(", "isGeneric", "(", "type", ")", "&&", "!", "type", ".", "isInterface", "(", ")", ")", "{", "if", "(", "GenericData", ".", "Record", ".", "class", ".", "equals", "(", "type", ")", ")", "{", "return", "(", "E", ")", "GenericData", ".", "get", "(", ")", ".", "newRecord", "(", "null", ",", "schema", ")", ";", "}", "return", "(", "E", ")", "ReflectData", ".", "newInstance", "(", "type", ",", "schema", ")", ";", "}", "return", "null", ";", "}" ]

[ "If", "E", "implements", "GenericRecord", "but", "does", "not", "implement", "SpecificRecord", "then", "create", "a", "new", "instance", "of", "E", "using", "reflection", "so", "that", "GenericDataumReader", "will", "use", "the", "expected", "type", "." ]

[ "public", "static", "GeoParser", "getDefault", "(", "String", "pathToLuceneIndex", ",", "LocationExtractor", "extractor", ",", "int", "maxHitDepth", ",", "int", "maxContentWindow", ",", "boolean", "fuzzy", ")", "throws", "ClavinException", "{", "// instantiate new LuceneGazetteer", "Gazetteer", "gazetteer", "=", "new", "LuceneGazetteer", "(", "new", "File", "(", "pathToLuceneIndex", ")", ")", ";", "return", "new", "GeoParser", "(", "extractor", ",", "gazetteer", ",", "maxHitDepth", ",", "maxContentWindow", ",", "fuzzy", ")", ";", "}" ]

[ "Get", "a", "GeoParser", "with", "defined", "values", "for", "maxHitDepth", "and", "maxContentWindow", "fuzzy", "matching", "explicitly", "turned", "on", "or", "off", "and", "a", "specific", "LocationExtractor", "to", "use", "." ]

[ "public", "static", "int", "writeIdenticalLevelRun", "(", "int", "prev", ",", "CharSequence", "s", ",", "int", "i", ",", "int", "length", ",", "ByteArrayWrapper", "sink", ")", "{", "while", "(", "i", "<", "length", ")", "{", "// We must have capacity>=SLOPE_MAX_BYTES in case writeDiff() writes that much,", "// but we do not want to force the sink to allocate", "// for a large min_capacity because we might actually only write one byte.", "ensureAppendCapacity", "(", "sink", ",", "16", ",", "s", ".", "length", "(", ")", "*", "2", ")", ";", "byte", "[", "]", "buffer", "=", "sink", ".", "bytes", ";", "int", "capacity", "=", "buffer", ".", "length", ";", "int", "p", "=", "sink", ".", "size", ";", "int", "lastSafe", "=", "capacity", "-", "SLOPE_MAX_BYTES_", ";", "while", "(", "i", "<", "length", "&&", "p", "<=", "lastSafe", ")", "{", "if", "(", "prev", "<", "0x4e00", "||", "prev", ">=", "0xa000", ")", "{", "prev", "=", "(", "prev", "&", "~", "0x7f", ")", "-", "SLOPE_REACH_NEG_1_", ";", "}", "else", "{", "// Unihan U+4e00..U+9fa5:", "// double-bytes down from the upper end", "prev", "=", "0x9fff", "-", "SLOPE_REACH_POS_2_", ";", "}", "int", "c", "=", "Character", ".", "codePointAt", "(", "s", ",", "i", ")", ";", "i", "+=", "Character", ".", "charCount", "(", "c", ")", ";", "if", "(", "c", "==", "0xfffe", ")", "{", "buffer", "[", "p", "++", "]", "=", "2", ";", "// merge separator", "prev", "=", "0", ";", "}", "else", "{", "p", "=", "writeDiff", "(", "c", "-", "prev", ",", "buffer", ",", "p", ")", ";", "prev", "=", "c", ";", "}", "}", "sink", ".", "size", "=", "p", ";", "}", "return", "prev", ";", "}" ]

[ "Encode", "the", "code", "points", "of", "a", "string", "as", "a", "sequence", "of", "byte", "-", "encoded", "differences", "(", "slope", "detection", ")", "preserving", "lexical", "order", "." ]

[ "public", "static", "Document", "resourceFileToXMLDocument", "(", "final", "String", "location", ",", "final", "String", "fileName", ")", "{", "if", "(", "location", "==", "null", "||", "fileName", "==", "null", ")", "return", "null", ";", "final", "InputStream", "in", "=", "ResourceUtilities", ".", "class", ".", "getResourceAsStream", "(", "location", "+", "fileName", ")", ";", "if", "(", "in", "==", "null", ")", "return", "null", ";", "final", "DocumentBuilderFactory", "dbFactory", "=", "DocumentBuilderFactory", ".", "newInstance", "(", ")", ";", "final", "DocumentBuilder", "dBuilder", ";", "Document", "doc", "=", "null", ";", "try", "{", "dBuilder", "=", "dbFactory", ".", "newDocumentBuilder", "(", ")", ";", "doc", "=", "dBuilder", ".", "parse", "(", "in", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "LOG", ".", "error", "(", "\"Failed to parse the resource as XML.\"", ",", "e", ")", ";", "}", "finally", "{", "try", "{", "in", ".", "close", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "LOG", ".", "error", "(", "\"Failed to close the InputStream\"", ",", "e", ")", ";", "}", "}", "return", "doc", ";", "}" ]

[ "Reads", "a", "resource", "file", "and", "converts", "it", "into", "a", "XML", "based", "Document", "object", "." ]

[ "public", "static", "void", "escapeCsv", "(", "final", "Reader", "reader", ",", "final", "Writer", "writer", ")", "throws", "IOException", "{", "if", "(", "writer", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Argument 'writer' cannot be null\"", ")", ";", "}", "CsvEscapeUtil", ".", "escape", "(", "reader", ",", "writer", ")", ";", "}" ]

[ "<p", ">", "Perform", "a", "CSV", "<strong", ">", "escape<", "/", "strong", ">", "operation", "on", "a", "<tt", ">", "Reader<", "/", "tt", ">", "input", "writing", "results", "to", "a", "<tt", ">", "Writer<", "/", "tt", ">", ".", "<", "/", "p", ">", "<p", ">", "This", "method", "is", "<strong", ">", "thread", "-", "safe<", "/", "strong", ">", ".", "<", "/", "p", ">" ]

[ "public", "V", "put", "(", "K", "pKey", ",", "V", "pValue", ")", "{", "if", "(", "!", "pKey", ".", "isCompatibleValue", "(", "pValue", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"incompatible value for key\"", ")", ";", "}", "return", "entries", ".", "put", "(", "pKey", ",", "pValue", ")", ";", "}" ]

[ "Associates", "the", "specified", "value", "with", "the", "specified", "key", "in", "this", "map", ".", "If", "the", "map", "previously", "contained", "a", "mapping", "for", "the", "key", "the", "old", "value", "is", "replaced", "." ]

[ "public", "static", "String", "formUrlEncode", "(", "Map", "<", "String", ",", "?", ">", "parameters", ")", "{", "if", "(", "parameters", "==", "null", ")", "{", "return", "null", ";", "}", "StringBuilder", "sb", "=", "new", "StringBuilder", "(", ")", ";", "// For each key-values pair.\r", "for", "(", "Map", ".", "Entry", "<", "String", ",", "?", ">", "entry", ":", "parameters", ".", "entrySet", "(", ")", ")", "{", "String", "key", "=", "entry", ".", "getKey", "(", ")", ";", "Object", "values", "=", "entry", ".", "getValue", "(", ")", ";", "if", "(", "values", "instanceof", "List", ")", "{", "List", "<", "?", ">", "list", "=", "(", "List", "<", "?", ">", ")", "values", ";", "values", "=", "list", ".", "toArray", "(", "new", "String", "[", "list", ".", "size", "(", ")", "]", ")", ";", "}", "appendParameters", "(", "sb", ",", "key", ",", "(", "String", "[", "]", ")", "values", ")", ";", "}", "if", "(", "sb", ".", "length", "(", ")", "!=", "0", ")", "{", "// Drop the last &.\r", "sb", ".", "setLength", "(", "sb", ".", "length", "(", ")", "-", "1", ")", ";", "}", "return", "sb", ".", "toString", "(", ")", ";", "}" ]

[ "Convert", "the", "given", "map", "to", "a", "string", "in", "{", "@code", "x", "-", "www", "-", "form", "-", "urlencoded", "}", "format", "." ]

[ "public", "static", "PHPMethodDescriptor", "findMethod", "(", "PHPClassDescriptor", "desc", ",", "String", "methodName", ")", "{", "PHPMethodDescriptor", "meth", ";", "meth", "=", "desc", ".", "getMethod", "(", "Helper", ".", "formatProcedureName", "(", "methodName", ")", ")", ";", "if", "(", "meth", "!=", "null", ")", "{", "return", "meth", ";", "}", "meth", "=", "desc", ".", "getMethod", "(", "\"get\"", "+", "Helper", ".", "formatProcedureName", "(", "methodName", ")", ")", ";", "if", "(", "meth", "!=", "null", ")", "{", "return", "meth", ";", "}", "return", "null", ";", "}" ]

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

[ "public", "static", "Instant", "nextInstant", "(", "Instant", "instant", ",", "Schedule", "schedule", ")", "{", "final", "ExecutionTime", "executionTime", "=", "ExecutionTime", ".", "forCron", "(", "cron", "(", "schedule", ")", ")", ";", "final", "ZonedDateTime", "utcDateTime", "=", "instant", ".", "atZone", "(", "UTC", ")", ";", "return", "executionTime", ".", "nextExecution", "(", "utcDateTime", ")", ".", "orElseThrow", "(", "IllegalArgumentException", "::", "new", ")", "// with unix cron, this should not happen", ".", "toInstant", "(", ")", ";", "}" ]

[ "Gets", "the", "next", "execution", "instant", "for", "a", "{", "@link", "Schedule", "}", "relative", "to", "a", "given", "instant", "." ]

[ "public", "static", "Double", "getPropertyDouble", "(", "Class", "<", "?", ">", "cls", ",", "String", "key", ")", "{", "return", "getSettings", "(", ")", ".", "getPropertyDouble", "(", "cls", ",", "key", ")", ";", "}" ]

[ "Get", "a", "double", "property" ]

[ "public", "void", "buildErrorSummary", "(", "XMLNode", "node", ",", "Content", "packageSummaryContentTree", ")", "{", "String", "errorTableSummary", "=", "configuration", ".", "getText", "(", "\"doclet.Member_Table_Summary\"", ",", "configuration", ".", "getText", "(", "\"doclet.Error_Summary\"", ")", ",", "configuration", ".", "getText", "(", "\"doclet.errors\"", ")", ")", ";", "String", "[", "]", "errorTableHeader", "=", "new", "String", "[", "]", "{", "configuration", ".", "getText", "(", "\"doclet.Error\"", ")", ",", "configuration", ".", "getText", "(", "\"doclet.Description\"", ")", "}", ";", "ClassDoc", "[", "]", "errors", "=", "pkg", ".", "errors", "(", ")", ";", "if", "(", "errors", ".", "length", ">", "0", ")", "{", "profileWriter", ".", "addClassesSummary", "(", "errors", ",", "configuration", ".", "getText", "(", "\"doclet.Error_Summary\"", ")", ",", "errorTableSummary", ",", "errorTableHeader", ",", "packageSummaryContentTree", ")", ";", "}", "}" ]

[ "Build", "the", "summary", "for", "the", "errors", "in", "the", "package", "." ]

[ "public", "static", "String", "openTagClassHtmlContent", "(", "String", "tag", ",", "String", "clazz", ",", "String", "...", "content", ")", "{", "return", "openTagHtmlContent", "(", "tag", ",", "clazz", ",", "null", ",", "content", ")", ";", "}" ]

[ "Build", "a", "String", "containing", "a", "HTML", "opening", "tag", "with", "given", "CSS", "class", "and", "concatenates", "the", "given", "HTML", "content", "." ]

[ "public", "TransientTypeSystem", "createTransientTypeSystem", "(", "TypesDef", "typesDef", ",", "boolean", "isUpdate", ")", "throws", "AtlasException", "{", "ImmutableList", "<", "EnumTypeDefinition", ">", "enumDefs", "=", "ImmutableList", ".", "copyOf", "(", "typesDef", ".", "enumTypesAsJavaList", "(", ")", ")", ";", "ImmutableList", "<", "StructTypeDefinition", ">", "structDefs", "=", "ImmutableList", ".", "copyOf", "(", "typesDef", ".", "structTypesAsJavaList", "(", ")", ")", ";", "ImmutableList", "<", "HierarchicalTypeDefinition", "<", "TraitType", ">", ">", "traitDefs", "=", "ImmutableList", ".", "copyOf", "(", "typesDef", ".", "traitTypesAsJavaList", "(", ")", ")", ";", "ImmutableList", "<", "HierarchicalTypeDefinition", "<", "ClassType", ">", ">", "classDefs", "=", "ImmutableList", ".", "copyOf", "(", "typesDef", ".", "classTypesAsJavaList", "(", ")", ")", ";", "TransientTypeSystem", "transientTypeSystem", "=", "new", "TransientTypeSystem", "(", "enumDefs", ",", "structDefs", ",", "traitDefs", ",", "classDefs", ")", ";", "transientTypeSystem", ".", "verifyTypes", "(", "isUpdate", ")", ";", "return", "transientTypeSystem", ";", "}" ]

[ "Create", "an", "instance", "of", "{", "@link", "TransientTypeSystem", "}", "with", "the", "types", "defined", "in", "the", "{", "@link", "TypesDef", "}", "." ]

[ "public", "BigInteger", "optBigInteger", "(", "int", "index", ",", "BigInteger", "defaultValue", ")", "{", "Object", "val", "=", "this", ".", "opt", "(", "index", ")", ";", "return", "JSONObject", ".", "objectToBigInteger", "(", "val", ",", "defaultValue", ")", ";", "}" ]

[ "Get", "the", "optional", "BigInteger", "value", "associated", "with", "an", "index", ".", "The", "defaultValue", "is", "returned", "if", "there", "is", "no", "value", "for", "the", "index", "or", "if", "the", "value", "is", "not", "a", "number", "and", "cannot", "be", "converted", "to", "a", "number", "." ]

[ "public", "static", "CharMatcher", "inRange", "(", "final", "char", "startInclusive", ",", "final", "char", "endInclusive", ")", "{", "checkArgument", "(", "endInclusive", ">=", "startInclusive", ")", ";", "return", "new", "FastMatcher", "(", ")", "{", "@", "Override", "public", "boolean", "matches", "(", "char", "c", ")", "{", "return", "startInclusive", "<=", "c", "&&", "c", "<=", "endInclusive", ";", "}", "@", "GwtIncompatible", "(", "\"java.util.BitSet\"", ")", "@", "Override", "void", "setBits", "(", "BitSet", "table", ")", "{", "table", ".", "set", "(", "startInclusive", ",", "endInclusive", "+", "1", ")", ";", "}", "@", "Override", "public", "String", "toString", "(", ")", "{", "return", "\"CharMatcher.inRange('\"", "+", "showCharacter", "(", "startInclusive", ")", "+", "\"', '\"", "+", "showCharacter", "(", "endInclusive", ")", "+", "\"')\"", ";", "}", "}", ";", "}" ]

[ "Returns", "a", "{", "@code", "char", "}", "matcher", "that", "matches", "any", "character", "in", "a", "given", "range", "(", "both", "endpoints", "are", "inclusive", ")", ".", "For", "example", "to", "match", "any", "lowercase", "letter", "of", "the", "English", "alphabet", "use", "{", "@code", "CharMatcher", ".", "inRange", "(", "a", "z", ")", "}", "." ]

[ "public", "static", "<", "E", ">", "BlockingQueue", "<", "E", ">", "getLimitedBlockingQueue", "(", "int", "maxQueue", ")", "{", "return", "new", "LinkedBlockingQueue", "<", "E", ">", "(", "maxQueue", ")", "{", "@", "Override", "public", "boolean", "offer", "(", "E", "e", ")", "{", "return", "putInsteadOfOffer", "(", "this", ",", "e", ")", ";", "}", "}", ";", "}" ]

[ "Gets", "limited", "blocking", "queue", "." ]

[ "public", "void", "moveSQLToField", "(", "ResultSet", "resultset", ",", "int", "iColumn", ")", "throws", "SQLException", "{", "java", ".", "util", ".", "Date", "dateResult", "=", "resultset", ".", "getDate", "(", "iColumn", ")", ";", "if", "(", "resultset", ".", "wasNull", "(", ")", ")", "this", ".", "setString", "(", "Constants", ".", "BLANK", ",", "false", ",", "DBConstants", ".", "READ_MOVE", ")", ";", "// Null value", "else", "this", ".", "setValue", "(", "(", "double", ")", "dateResult", ".", "getTime", "(", ")", ",", "false", ",", "DBConstants", ".", "READ_MOVE", ")", ";", "}" ]

[ "Move", "the", "physical", "binary", "data", "to", "this", "SQL", "parameter", "row", "." ]

[ "public", "void", "addCharset", "(", "String", "nioCharsetName", ",", "Charset", "cloudhopperCharset", ")", "{", "LOG", ".", "debug", "(", "\"Added charset mapping nio {} -> {}\"", ",", "nioCharsetName", ",", "cloudhopperCharset", ")", ";", "mapCloudhopperCharsetByNioCharsetName", ".", "put", "(", "nioCharsetName", ",", "cloudhopperCharset", ")", ";", "}" ]

[ "Add", "a", "charset", "mapping", "." ]

[ "@", "Override", "public", "final", "boolean", "isValid", "(", "final", "Object", "pvalue", ",", "final", "ConstraintValidatorContext", "pcontext", ")", "{", "final", "String", "valueAsString", "=", "Objects", ".", "toString", "(", "pvalue", ",", "null", ")", ";", "if", "(", "StringUtils", ".", "isEmpty", "(", "valueAsString", ")", ")", "{", "return", "true", ";", "}", "if", "(", "valueAsString", ".", "length", "(", ")", "!=", "ISIN_LENGTH", ")", "{", "// ISIN size is wrong, but that's handled by size annotation", "return", "true", ";", "}", "// calculate and check checksum (ISIN)", "return", "CHECK_ISIN", ".", "isValid", "(", "valueAsString", ")", ";", "}" ]

[ "{", "@inheritDoc", "}", "check", "if", "given", "string", "is", "a", "valid", "isin", "." ]

[ "static", "User", "findByKey", "(", "final", "EntityManager", "em", ",", "final", "String", "userId", ")", "{", "User", "user", "=", "em", ".", "find", "(", "User", ".", "class", ",", "userId", ")", ";", "logger", ".", "info", "(", "\"[On Find by key]\"", ")", ";", "System", ".", "out", ".", "println", "(", "\"#######################START##########################################\"", ")", ";", "logger", ".", "info", "(", "\"\\n\"", ")", ";", "logger", ".", "info", "(", "\"\\t\\t User's first name:\"", "+", "user", ".", "getFirstName", "(", ")", ")", ";", "logger", ".", "info", "(", "\"\\t\\t User's emailId:\"", "+", "user", ".", "getEmailId", "(", ")", ")", ";", "logger", ".", "info", "(", "\"\\t\\t User's Personal Details:\"", "+", "user", ".", "getPersonalDetail", "(", ")", ".", "getName", "(", ")", ")", ";", "logger", ".", "info", "(", "\"\\t\\t User's Personal Details:\"", "+", "user", ".", "getPersonalDetail", "(", ")", ".", "getPassword", "(", ")", ")", ";", "logger", ".", "info", "(", "\"\\t\\t User's total tweets:\"", "+", "user", ".", "getTweets", "(", ")", ".", "size", "(", ")", ")", ";", "logger", ".", "info", "(", "\"\\n\"", ")", ";", "System", ".", "out", ".", "println", "(", "\"#######################END############################################\"", ")", ";", "logger", ".", "info", "(", "\"\\n\"", ")", ";", "return", "user", ";", "}" ]

[ "On", "find", "by", "user", "id", "." ]

[ "public", "static", "ServiceActor", "RunTCP", "(", "String", "args", "[", "]", ",", "Class", "<", "?", "extends", "ServiceActor", ">", "serviceClazz", ",", "Class", "<", "?", "extends", "ServiceArgs", ">", "argsClazz", ")", "{", "ServiceActor", "myService", "=", "AsActor", "(", "serviceClazz", ")", ";", "ServiceArgs", "options", "=", "null", ";", "try", "{", "options", "=", "ServiceRegistry", ".", "parseCommandLine", "(", "args", ",", "null", ",", "argsClazz", ".", "newInstance", "(", ")", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "FSTUtil", ".", "rethrow", "(", "e", ")", ";", "}", "TCPConnectable", "connectable", "=", "new", "TCPConnectable", "(", "ServiceRegistry", ".", "class", ",", "options", ".", "getRegistryHost", "(", ")", ",", "options", ".", "getRegistryPort", "(", ")", ")", ";", "myService", ".", "init", "(", "connectable", ",", "options", ",", "true", ")", ".", "await", "(", "30_000", ")", ";", "Log", ".", "Info", "(", "myService", ".", "getClass", "(", ")", ",", "\"Init finished\"", ")", ";", "return", "myService", ";", "}" ]

[ "run", "&", "connect", "a", "service", "with", "given", "cmdline", "args", "and", "classes" ]

[ "public", "static", "MimeType", "getMimeType", "(", "String", "name", ",", "Property", "property", ")", "{", "MimeType", "result", "=", "null", ";", "try", "{", "Binary", "binary", "=", "property", "!=", "null", "?", "property", ".", "getBinary", "(", ")", ":", "null", ";", "if", "(", "binary", "!=", "null", ")", "{", "try", "{", "InputStream", "input", "=", "binary", ".", "getStream", "(", ")", ";", "try", "{", "MediaType", "mediaType", "=", "getMediaType", "(", "input", ",", "name", ")", ";", "if", "(", "mediaType", "!=", "null", ")", "{", "try", "{", "result", "=", "getMimeTypes", "(", ")", ".", "forName", "(", "mediaType", ".", "toString", "(", ")", ")", ";", "}", "catch", "(", "MimeTypeException", "e1", ")", "{", "// detection not successful", "}", "}", "}", "finally", "{", "try", "{", "input", ".", "close", "(", ")", ";", "}", "catch", "(", "IOException", "ioex", ")", "{", "LOG", ".", "error", "(", "ioex", ".", "toString", "(", ")", ")", ";", "}", "}", "}", "finally", "{", "binary", ".", "dispose", "(", ")", ";", "}", "}", "}", "catch", "(", "RepositoryException", "rex", ")", "{", "LOG", ".", "error", "(", "rex", ".", "toString", "(", ")", ")", ";", "}", "return", "result", ";", "}" ]

[ "Detects", "the", "mime", "type", "of", "a", "binary", "property", "in", "the", "context", "of", "the", "nodes", "name", "." ]

[ "private", "CompletableFuture", "<", "ProcessorCollection", ">", "getProcessor", "(", "long", "streamSegmentId", ")", "{", "ProcessorCollection", "existingProcessor", "=", "this", ".", "processors", ".", "getOrDefault", "(", "streamSegmentId", ",", "null", ")", ";", "if", "(", "existingProcessor", "!=", "null", ")", "{", "if", "(", "closeIfNecessary", "(", "existingProcessor", ")", ".", "isClosed", "(", ")", ")", "{", "// Existing SegmentAggregator has become stale (most likely due to its SegmentMetadata being evicted),", "// so it has been closed and we need to create a new one.", "this", ".", "processors", ".", "remove", "(", "streamSegmentId", ")", ";", "}", "else", "{", "return", "CompletableFuture", ".", "completedFuture", "(", "existingProcessor", ")", ";", "}", "}", "// Get the SegmentAggregator's Metadata.", "UpdateableSegmentMetadata", "segmentMetadata", "=", "this", ".", "dataSource", ".", "getStreamSegmentMetadata", "(", "streamSegmentId", ")", ";", "if", "(", "segmentMetadata", "==", "null", ")", "{", "return", "Futures", ".", "failedFuture", "(", "new", "DataCorruptionException", "(", "String", ".", "format", "(", "\"No StreamSegment with id '%d' is registered in the metadata.\"", ",", "streamSegmentId", ")", ")", ")", ";", "}", "// Then create the aggregator, and only register it after a successful initialization. Otherwise we risk", "// having a registered aggregator that is not initialized.", "SegmentAggregator", "newAggregator", "=", "new", "SegmentAggregator", "(", "segmentMetadata", ",", "this", ".", "dataSource", ",", "this", ".", "storage", ",", "this", ".", "config", ",", "this", ".", "timer", ",", "this", ".", "executor", ")", ";", "ProcessorCollection", "pc", "=", "new", "ProcessorCollection", "(", "newAggregator", ",", "this", ".", "createProcessors", ".", "apply", "(", "segmentMetadata", ")", ")", ";", "try", "{", "CompletableFuture", "<", "Void", ">", "init", "=", "newAggregator", ".", "initialize", "(", "this", ".", "config", ".", "getFlushTimeout", "(", ")", ")", ";", "Futures", ".", "exceptionListener", "(", "init", ",", "ex", "->", "newAggregator", ".", "close", "(", ")", ")", ";", "return", "init", ".", "thenApply", "(", "ignored", "->", "{", "this", ".", "processors", ".", "put", "(", "streamSegmentId", ",", "pc", ")", ";", "return", "pc", ";", "}", ")", ";", "}", "catch", "(", "Exception", "ex", ")", "{", "pc", ".", "close", "(", ")", ";", "throw", "ex", ";", "}", "}" ]

[ "Gets", "or", "creates", "a", "SegmentAggregator", "for", "the", "given", "StorageOperation", "." ]

[ "private", "void", "processSetColorOps", "(", "String", "methodName", ")", "throws", "ClassNotFoundException", "{", "if", "(", "\"setBackground\"", ".", "equals", "(", "methodName", ")", "||", "\"setForeground\"", ".", "equals", "(", "methodName", ")", ")", "{", "int", "argCount", "=", "SignatureUtils", ".", "getNumParameters", "(", "getSigConstantOperand", "(", ")", ")", ";", "if", "(", "stack", ".", "getStackDepth", "(", ")", ">", "argCount", ")", "{", "OpcodeStack", ".", "Item", "item", "=", "stack", ".", "getStackItem", "(", "0", ")", ";", "if", "(", "S508UserValue", ".", "FROM_UIMANAGER", "!=", "item", ".", "getUserValue", "(", ")", ")", "{", "item", "=", "stack", ".", "getStackItem", "(", "argCount", ")", ";", "JavaClass", "cls", "=", "item", ".", "getJavaClass", "(", ")", ";", "if", "(", "(", "(", "jcomponentClass", "!=", "null", ")", "&&", "cls", ".", "instanceOf", "(", "jcomponentClass", ")", ")", "||", "(", "(", "componentClass", "!=", "null", ")", "&&", "cls", ".", "instanceOf", "(", "componentClass", ")", ")", ")", "{", "bugReporter", ".", "reportBug", "(", "new", "BugInstance", "(", "this", ",", "BugType", ".", "S508C_SET_COMP_COLOR", ".", "name", "(", ")", ",", "NORMAL_PRIORITY", ")", ".", "addClass", "(", "this", ")", ".", "addMethod", "(", "this", ")", ".", "addSourceLine", "(", "this", ")", ")", ";", "}", "}", "}", "}", "}" ]

[ "looks", "for", "calls", "to", "set", "the", "color", "of", "components", "where", "the", "color", "isn", "t", "from", "UIManager" ]

[ "public", "Integer", "getNodesPartitionIdForKey", "(", "int", "nodeId", ",", "final", "byte", "[", "]", "key", ")", "{", "// this is all the partitions the key replicates to.", "List", "<", "Integer", ">", "partitionIds", "=", "getReplicatingPartitionList", "(", "key", ")", ";", "for", "(", "Integer", "partitionId", ":", "partitionIds", ")", "{", "// check which of the replicating partitions belongs to the node in", "// question", "if", "(", "getNodeIdForPartitionId", "(", "partitionId", ")", "==", "nodeId", ")", "{", "return", "partitionId", ";", "}", "}", "return", "null", ";", "}" ]

[ "Determines", "the", "partition", "ID", "that", "replicates", "the", "key", "on", "the", "given", "node", "." ]

[ "private", "static", "void", "updateCustomHashtable", "(", "Hashtable", "<", "String", ",", "Object", ">", "credData", ",", "String", "realmName", ",", "String", "uniqueId", ",", "String", "securityName", ",", "List", "<", "?", ">", "groupList", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "{", "Tr", ".", "entry", "(", "tc", ",", "\"updateCustomHashtable\"", ",", "new", "Object", "[", "]", "{", "credData", ",", "realmName", ",", "uniqueId", ",", "securityName", ",", "groupList", "}", ")", ";", "}", "String", "cacheKey", "=", "getCacheKey", "(", "uniqueId", ",", "realmName", ")", ";", "credData", ".", "put", "(", "AttributeNameConstants", ".", "WSCREDENTIAL_CACHE_KEY", ",", "cacheKey", ")", ";", "credData", ".", "put", "(", "AttributeNameConstants", ".", "WSCREDENTIAL_REALM", ",", "realmName", ")", ";", "credData", ".", "put", "(", "AttributeNameConstants", ".", "WSCREDENTIAL_SECURITYNAME", ",", "securityName", ")", ";", "if", "(", "uniqueId", "!=", "null", ")", "{", "credData", ".", "put", "(", "AttributeNameConstants", ".", "WSCREDENTIAL_UNIQUEID", ",", "uniqueId", ")", ";", "}", "// If uniqueId is not set then the login will fail later and the work will not execute", "if", "(", "groupList", "!=", "null", "&&", "!", "groupList", ".", "isEmpty", "(", ")", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"Adding groups found in registry\"", ",", "groupList", ")", ";", "}", "credData", ".", "put", "(", "AttributeNameConstants", ".", "WSCREDENTIAL_GROUPS", ",", "groupList", ")", ";", "}", "else", "{", "credData", ".", "put", "(", "AttributeNameConstants", ".", "WSCREDENTIAL_GROUPS", ",", "new", "ArrayList", "<", "String", ">", "(", ")", ")", ";", "}", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "{", "Tr", ".", "exit", "(", "tc", ",", "\"updateCustomHashtable\"", ")", ";", "}", "}" ]

[ "This", "method", "updates", "the", "hashtable", "provided", "with", "the", "information", "that", "is", "required", "for", "custom", "hashtable", "login", ".", "The", "hashtable", "should", "contain", "the", "following", "parameters", "for", "this", "to", "succeed", ".", "Key", ":", "com", ".", "ibm", ".", "wsspi", ".", "security", ".", "cred", ".", "uniqueId", "Value", ":", "user", ":", "ldap", ".", "austin", ".", "ibm", ".", "com", ":", "389", "/", "cn", "=", "pbirk", "o", "=", "ibm", "c", "=", "us", "Key", ":", "com", ".", "ibm", ".", "wsspi", ".", "security", ".", "cred", ".", "realm", "Value", ":", "ldap", ".", "austin", ".", "ibm", ".", "com", ":", "389", "Key", ":", "com", ".", "ibm", ".", "wsspi", ".", "security", ".", "cred", ".", "securityName", "Value", ":", "pbirk", "Key", ":", "com", ".", "ibm", ".", "wsspi", ".", "security", ".", "cred", ".", "longSecurityName", "Value", ":", "cn", "=", "pbirk", "o", "=", "ibm", "c", "=", "us", "(", "Optional", ")", "Key", ":", "com", ".", "ibm", ".", "wsspi", ".", "security", ".", "cred", ".", "groups", "Value", ":", "group", ":", "cn", "=", "group1", "o", "=", "ibm", "c", "=", "us|", "group", ":", "cn", "=", "group2", "o", "=", "ibm", "c", "=", "us|group", ":", "cn", "=", "group3", "o", "=", "ibm", "c", "=", "us", "Key", ":", "com", ".", "ibm", ".", "wsspi", ".", "security", ".", "cred", ".", "cacheKey", "Value", ":", "Location", ":", "9", ".", "43", ".", "21", ".", "23", "(", "note", ":", "accessID", "gets", "appended", "to", "this", "value", "for", "cache", "lookup", ")", "." ]

[ "public", "static", "Pattern", "times", "(", "final", "int", "min", ",", "final", "int", "max", ",", "final", "CharPredicate", "predicate", ")", "{", "Checks", ".", "checkMinMax", "(", "min", ",", "max", ")", ";", "return", "new", "Pattern", "(", ")", "{", "@", "Override", "public", "int", "match", "(", "CharSequence", "src", ",", "int", "begin", ",", "int", "end", ")", "{", "int", "minLen", "=", "RepeatCharPredicatePattern", ".", "matchRepeat", "(", "min", ",", "predicate", ",", "src", ",", "end", ",", "begin", ",", "0", ")", ";", "if", "(", "minLen", "==", "MISMATCH", ")", "return", "MISMATCH", ";", "return", "matchSome", "(", "max", "-", "min", ",", "predicate", ",", "src", ",", "end", ",", "begin", "+", "minLen", ",", "minLen", ")", ";", "}", "}", ";", "}" ]

[ "Returns", "a", "{", "@link", "Pattern", "}", "that", "matches", "at", "least", "{", "@code", "min", "}", "and", "up", "to", "{", "@code", "max", "}", "number", "of", "characters", "satisfying", "{", "@code", "predicate", "}" ]

[ "protected", "void", "sqlGroupProjection", "(", "String", "sql", ",", "String", "groupBy", ",", "List", "<", "String", ">", "columnAliases", ",", "List", "<", "Type", ">", "types", ")", "{", "projectionList", ".", "add", "(", "Projections", ".", "sqlGroupProjection", "(", "sql", ",", "groupBy", ",", "columnAliases", ".", "toArray", "(", "new", "String", "[", "columnAliases", ".", "size", "(", ")", "]", ")", ",", "types", ".", "toArray", "(", "new", "Type", "[", "types", ".", "size", "(", ")", "]", ")", ")", ")", ";", "}" ]

[ "Adds", "a", "sql", "projection", "to", "the", "criteria" ]

[ "public", "void", "setPrivateKey", "(", "String", "privateKeyLocation", ",", "String", "keyPassword", ")", "{", "InputStream", "privateKeyInputStream", "=", "null", ";", "try", "{", "privateKeyInputStream", "=", "new", "FileInputStream", "(", "privateKeyLocation", ")", ";", "}", "catch", "(", "FileNotFoundException", "fnfe", ")", "{", "throw", "new", "KeyException", "(", "\"La ubicación del archivo de la llave privada es incorrecta\",", " ", "nfe.", "g", "etCause(", ")", ")", ";", "", "}", "this", ".", "setPrivateKey", "(", "privateKeyInputStream", ",", "keyPassword", ")", ";", "}" ]

[ "@param", "privateKeyLocation", "private", "key", "located", "in", "filesystem", "@param", "keyPassword", "private", "key", "password" ]

[ "public", "static", "HashinatorSnapshotData", "serializeConfiguredHashinator", "(", ")", "throws", "IOException", "{", "Pair", "<", "Long", ",", "?", "extends", "TheHashinator", ">", "currentInstance", "=", "instance", ".", "get", "(", ")", ";", "byte", "[", "]", "cookedData", "=", "currentInstance", ".", "getSecond", "(", ")", ".", "getCookedBytes", "(", ")", ";", "return", "new", "HashinatorSnapshotData", "(", "cookedData", ",", "currentInstance", ".", "getFirst", "(", ")", ")", ";", "}" ]

[ "Get", "optimized", "configuration", "data", "for", "wire", "serialization", "." ]

[ "public", "static", "boolean", "isPortAvailable", "(", "String", "host", ",", "int", "port", ")", "{", "try", "{", "Socket", "socket", "=", "new", "Socket", "(", "host", ",", "port", ")", ";", "socket", ".", "close", "(", ")", ";", "return", "false", ";", "}", "catch", "(", "IOException", "e", ")", "{", "return", "true", ";", "}", "}" ]

[ "See", "if", "a", "port", "is", "available", "for", "listening", "on", "by", "trying", "connect", "to", "it", "and", "seeing", "if", "that", "works", "or", "fails" ]

[ "private", "static", "boolean", "equalsMayBeNullOrZeroLen", "(", "String", "s1", ",", "String", "s2", ")", "{", "int", "len1", "=", "(", "s1", "==", "null", ")", "?", "0", ":", "s1", ".", "length", "(", ")", ";", "int", "len2", "=", "(", "s2", "==", "null", ")", "?", "0", ":", "s2", ".", "length", "(", ")", ";", "return", "(", "len1", "!=", "len2", ")", "?", "false", ":", "(", "len1", "==", "0", ")", "?", "true", ":", "s1", ".", "equals", "(", "s2", ")", ";", "}" ]

[ "Tell", "if", "the", "two", "string", "refs", "are", "equal", "equality", "being", "defined", "as", ":", "1", ")", "Both", "strings", "are", "null", ".", "2", ")", "One", "string", "is", "null", "and", "the", "other", "is", "empty", ".", "3", ")", "Both", "strings", "are", "non", "-", "null", "and", "equal", "." ]

[ "private", "void", "definePanels", "(", "UIDefaults", "d", ")", "{", "String", "p", "=", "\"Panel\"", ";", "d", ".", "put", "(", "p", "+", "\".contentMargins\"", ",", "new", "InsetsUIResource", "(", "0", ",", "0", ",", "0", ",", "0", ")", ")", ";", "d", ".", "put", "(", "p", "+", "\".background\"", ",", "new", "ColorUIResource", "(", "(", "Color", ")", "d", ".", "get", "(", "\"control\"", ")", ")", ")", ";", "d", ".", "put", "(", "p", "+", "\".opaque\"", ",", "Boolean", ".", "TRUE", ")", ";", "}" ]

[ "Initialize", "the", "panel", "settings", "." ]

[ "public", "static", "Range", "rangeOf", "(", "final", "String", "beginToken", ",", "final", "String", "endToken", ",", "final", "String", "string", ")", "{", "return", "rangeOf", "(", "beginToken", ",", "endToken", ",", "string", ",", "0", ")", ";", "}" ]

[ "Return", "the", "range", "from", "a", "begining", "token", "to", "an", "ending", "token", "." ]

[ "public", "void", "setMedia", "(", "String", "media", ")", "throws", "FlickrException", "{", "if", "(", "media", ".", "equals", "(", "\"all\"", ")", "||", "media", ".", "equals", "(", "\"photos\"", ")", "||", "media", ".", "equals", "(", "\"videos\"", ")", ")", "{", "this", ".", "media", "=", "media", ";", "}", "else", "{", "throw", "new", "FlickrException", "(", "\"0\"", ",", "\"Media type is not valid.\"", ")", ";", "}", "}" ]

[ "Filter", "results", "by", "media", "type", ".", "Possible", "values", "are", "all", "(", "default", ")", "photos", "or", "videos", "." ]