Datasets:

---

stojchet

/

base_prediction_dataset

like 0

[ "public", "boolean", "ignoreOperation", "(", "final", "Resource", "domainResource", ",", "final", "Collection", "<", "ServerConfigInfo", ">", "serverConfigs", ",", "final", "PathAddress", "pathAddress", ")", "{", "if", "(", "pathAddress", ".", "size", "(", ")", "==", "0", ")", "{", "return", "false", ";", "}", "boolean", "ignore", "=", "ignoreResourceInternal", "(", "domainResource", ",", "serverConfigs", ",", "pathAddress", ")", ";", "return", "ignore", ";", "}" ]

[ "For", "the", "DC", "to", "check", "whether", "an", "operation", "should", "be", "ignored", "on", "the", "slave", "if", "the", "slave", "is", "set", "up", "to", "ignore", "config", "not", "relevant", "to", "it" ]

[ "public", "static", "Double", "getDoubleValue", "(", "JSONObject", "jsonObject", ",", "String", "key", ")", "throws", "JSONException", "{", "checkArguments", "(", "jsonObject", ",", "key", ")", ";", "JSONValue", "value", "=", "jsonObject", ".", "get", "(", "key", ")", ";", "if", "(", "value", "!=", "null", "&&", "value", ".", "isNumber", "(", ")", "!=", "null", ")", "{", "double", "number", "=", "(", "(", "JSONNumber", ")", "value", ")", ".", "doubleValue", "(", ")", ";", "return", "number", ";", "}", "return", "null", ";", "}" ]

[ "Get", "a", "double", "value", "from", "a", "{", "@link", "JSONObject", "}", "." ]

[ "public", "static", "String", "getString", "(", "String", "key", ",", "String", "valueIfNull", ")", "{", "String", "value", "=", "System", ".", "getProperty", "(", "key", ")", ";", "if", "(", "Strings", ".", "isNullOrEmpty", "(", "value", ")", ")", "{", "return", "valueIfNull", ";", "}", "return", "value", ";", "}" ]

[ "Gets", "a", "system", "property", "string", "or", "a", "replacement", "value", "if", "the", "property", "is", "null", "or", "blank", "." ]

[ "public", "MetadataBuilder", "addDataSource", "(", "@", "NotNull", "InputStream", "dataSource", ",", "String", "path", ",", "boolean", "closeAfterBuild", ")", "{", "checkHashingResultIsNotSet", "(", ")", ";", "filesPaths", ".", "add", "(", "path", ")", ";", "dataSources", ".", "add", "(", "new", "StreamBasedHolderImpl", "(", "dataSource", ",", "closeAfterBuild", ")", ")", ";", "return", "this", ";", "}" ]

[ "add", "custom", "source", "in", "torrent", "with", "custom", "path", ".", "Path", "can", "be", "separated", "with", "any", "slash", "." ]

[ "public", "String", "getEstimatedTimeRemaining", "(", "double", "theCompleteToDate", ",", "double", "theTotal", ")", "{", "double", "millis", "=", "getMillis", "(", ")", ";", "long", "millisRemaining", "=", "(", "long", ")", "(", "(", "(", "theTotal", "/", "theCompleteToDate", ")", "*", "millis", ")", "-", "(", "millis", ")", ")", ";", "return", "formatMillis", "(", "millisRemaining", ")", ";", "}" ]

[ "Given", "an", "amount", "of", "something", "completed", "so", "far", "and", "a", "total", "amount", "calculates", "how", "long", "it", "will", "take", "for", "something", "to", "complete" ]

[ "public", "static", "float", "getFloat", "(", "JsonObject", "object", ",", "String", "field", ",", "float", "defaultValue", ")", "{", "final", "JsonValue", "value", "=", "object", ".", "get", "(", "field", ")", ";", "if", "(", "value", "==", "null", "||", "value", ".", "isNull", "(", ")", ")", "{", "return", "defaultValue", ";", "}", "else", "{", "return", "value", ".", "asFloat", "(", ")", ";", "}", "}" ]

[ "Returns", "a", "field", "in", "a", "Json", "object", "as", "a", "float", "." ]

[ "public", "void", "notifyEnd", "(", "String", "projectApiId", ",", "String", "projectVersion", ",", "String", "category", ",", "long", "duration", ")", "{", "try", "{", "if", "(", "isStarted", "(", ")", ")", "{", "JSONObject", "endNotification", "=", "new", "JSONObject", "(", ")", ".", "put", "(", "\"project\"", ",", "new", "JSONObject", "(", ")", ".", "put", "(", "\"apiId\"", ",", "projectApiId", ")", ".", "put", "(", "\"version\"", ",", "projectVersion", ")", ")", ".", "put", "(", "\"category\"", ",", "category", ")", ".", "put", "(", "\"duration\"", ",", "duration", ")", ";", "socket", ".", "emit", "(", "\"run:end\"", ",", "endNotification", ")", ";", "}", "else", "{", "LOGGER", ".", "log", "(", "Level", ".", "WARNING", ",", "\"Probe Dock RT is not available to send the end notification\"", ")", ";", "}", "}", "catch", "(", "Exception", "e", ")", "{", "LOGGER", ".", "log", "(", "Level", ".", "INFO", ",", "\"Unable to send the end notification to the agent. Cause: \"", "+", "e", ".", "getMessage", "(", ")", ")", ";", "if", "(", "LOGGER", ".", "getLevel", "(", ")", "==", "Level", ".", "FINEST", ")", "{", "LOGGER", ".", "log", "(", "Level", ".", "FINEST", ",", "\"Exception:\"", ",", "e", ")", ";", "}", "}", "}" ]

[ "Send", "a", "ending", "notification", "to", "the", "agent" ]

[ "public", "ReportWriter", "getReportWriter", "(", "final", "JasperPrint", "_jasperPrint", ",", "final", "String", "_format", ",", "final", "Map", "<", "JRExporterParameter", ",", "Object", ">", "_parameters", ")", "{", "final", "JRExporter", "exporter", "=", "FormatInfoRegistry", ".", "getInstance", "(", ")", ".", "getExporter", "(", "_format", ")", ";", "exporter", ".", "setParameters", "(", "_parameters", ")", ";", "if", "(", "_jasperPrint", ".", "getPages", "(", ")", ".", "size", "(", ")", ">", "PAGES_THRESHHOLD", ")", "{", "return", "new", "FileReportWriter", "(", "_jasperPrint", ",", "exporter", ")", ";", "}", "else", "{", "return", "new", "MemoryReportWriter", "(", "_jasperPrint", ",", "exporter", ")", ";", "}", "}" ]

[ "Returns", "a", "ReportWriter", "that", "which", "will", "use", "memory", "or", "a", "file", "depending", "on", "the", "parameter", "PAGES_THRESHOLD" ]

[ "@", "SuppressWarnings", "(", "{", "\"WeakerAccess\"", ",", "\"unused\"", "}", ")", "// For library users", "@", "Deprecated", "// TODO Remove in 2.0", "public", "void", "addFacet", "(", "@", "NonNull", "String", "attribute", ",", "boolean", "isDisjunctive", ",", "@", "Nullable", "List", "<", "String", ">", "values", ")", "{", "addFacetRefinement", "(", "attribute", ",", "values", ",", "isDisjunctive", ")", ";", "}" ]

[ "Adds", "a", "facet", "refinement", "for", "the", "next", "queries", "." ]

[ "private", "void", "readFrom", "(", "InputStream", "inputStream", ",", "Consumer", "<", "GraphicalModel", ">", "featurizer", ")", "throws", "IOException", "{", "GraphicalModel", "read", ";", "while", "(", "(", "read", "=", "GraphicalModel", ".", "readFromStream", "(", "inputStream", ")", ")", "!=", "null", ")", "{", "featurizer", ".", "accept", "(", "read", ")", ";", "add", "(", "read", ")", ";", "}", "}" ]

[ "Load", "a", "batch", "of", "models", "from", "disk", "while", "running", "the", "function", "featurizer", "on", "each", "of", "the", "models", "before", "adding", "it", "to", "the", "batch", ".", "This", "gives", "the", "loader", "a", "chance", "to", "experiment", "with", "new", "featurization", "techniques", "." ]

[ "@", "Override", "public", "void", "setRowId", "(", "int", "parameterIndex", ",", "RowId", "x", ")", "throws", "SQLException", "{", "internalStmt", ".", "setRowId", "(", "parameterIndex", ",", "x", ")", ";", "}" ]

[ "Method", "setRowId", "." ]

[ "public", "static", "CmsJspContentAttachmentsBean", "getAttachmentsForCurrentPage", "(", "CmsObject", "cms", ",", "CmsResource", "content", ")", "throws", "CmsException", "{", "CmsResource", "page", "=", "cms", ".", "readResource", "(", "cms", ".", "getRequestContext", "(", ")", ".", "getUri", "(", ")", ",", "CmsResourceFilter", ".", "IGNORE_EXPIRATION", ")", ";", "String", "locale", "=", "CmsDetailOnlyContainerUtil", ".", "getDetailContainerLocale", "(", "cms", ",", "cms", ".", "getRequestContext", "(", ")", ".", "getLocale", "(", ")", ".", "toString", "(", ")", ",", "page", ")", ";", "Optional", "<", "CmsResource", ">", "detailOnly", "=", "CmsDetailOnlyContainerUtil", ".", "getDetailOnlyPage", "(", "cms", ",", "content", ",", "locale", ")", ";", "if", "(", "detailOnly", ".", "isPresent", "(", ")", ")", "{", "try", "{", "return", "new", "CmsJspContentAttachmentsBean", "(", "cms", ",", "detailOnly", ".", "get", "(", ")", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "LOG", ".", "error", "(", "e", ".", "getLocalizedMessage", "(", ")", ",", "e", ")", ";", "return", "new", "CmsJspContentAttachmentsBean", "(", ")", ";", "}", "}", "else", "{", "return", "new", "CmsJspContentAttachmentsBean", "(", ")", ";", "}", "}" ]

[ "Gets", "the", "attachments", "/", "detail", "-", "only", "contents", "for", "the", "current", "page", "(", "i", ".", "e", ".", "cms", ".", "getRequestContext", "()", ".", "getUri", "()", ")", ".", "<p", ">" ]

[ "public", "void", "addAndExpression", "(", "final", "INodeReadTrx", "mTransaction", ")", "{", "assert", "getPipeStack", "(", ")", ".", "size", "(", ")", ">=", "2", ";", "final", "AbsAxis", "mOperand2", "=", "getPipeStack", "(", ")", ".", "pop", "(", ")", ".", "getExpr", "(", ")", ";", "final", "AbsAxis", "operand1", "=", "getPipeStack", "(", ")", ".", "pop", "(", ")", ".", "getExpr", "(", ")", ";", "if", "(", "getPipeStack", "(", ")", ".", "empty", "(", ")", "||", "getExpression", "(", ")", ".", "getSize", "(", ")", "!=", "0", ")", "{", "addExpressionSingle", "(", ")", ";", "}", "getExpression", "(", ")", ".", "add", "(", "new", "AndExpr", "(", "mTransaction", ",", "operand1", ",", "mOperand2", ")", ")", ";", "}" ]

[ "Adds", "a", "and", "expression", "to", "the", "pipeline", "." ]

[ "private", "void", "assignSegmentId", "(", "String", "segmentName", ",", "Duration", "timeout", ")", "{", "TimeoutTimer", "timer", "=", "new", "TimeoutTimer", "(", "timeout", ")", ";", "Futures", ".", "exceptionListener", "(", "getSegmentInfoInternal", "(", "segmentName", ",", "timer", ".", "getRemaining", "(", ")", ")", ".", "thenComposeAsync", "(", "si", "->", "submitAssignmentWithRetry", "(", "SegmentInfo", ".", "deserialize", "(", "si", ")", ",", "timer", ".", "getRemaining", "(", ")", ")", ",", "this", ".", "executor", ")", ",", "ex", "->", "failAssignment", "(", "segmentName", ",", "ex", ")", ")", ";", "}" ]

[ "Attempts", "to", "map", "a", "Segment", "to", "an", "Id", "by", "first", "trying", "to", "retrieve", "an", "existing", "id", "and", "should", "that", "not", "exist", "assign", "a", "new", "one", "." ]

[ "public", "static", "SparseVector", "random", "(", "int", "length", ",", "double", "density", ",", "Random", "random", ")", "{", "return", "CompressedVector", ".", "random", "(", "length", ",", "density", ",", "random", ")", ";", "}" ]

[ "Creates", "a", "constant", "{" ]

[ "private", "boolean", "isDeletedResource", "(", "String", "path", ",", "boolean", "rootPath", ")", "{", "CmsObject", "cms", "=", "getCmsObject", "(", ")", ";", "CmsResource", "res", "=", "null", ";", "try", "{", "if", "(", "rootPath", ")", "{", "String", "origSiteRoot", "=", "cms", ".", "getRequestContext", "(", ")", ".", "getSiteRoot", "(", ")", ";", "try", "{", "cms", ".", "getRequestContext", "(", ")", ".", "setSiteRoot", "(", "\"\"", ")", ";", "res", "=", "cms", ".", "readResource", "(", "path", ",", "CmsResourceFilter", ".", "ALL", ")", ";", "}", "finally", "{", "cms", ".", "getRequestContext", "(", ")", ".", "setSiteRoot", "(", "origSiteRoot", ")", ";", "}", "}", "else", "{", "res", "=", "cms", ".", "readResource", "(", "path", ",", "CmsResourceFilter", ".", "ALL", ")", ";", "}", "}", "catch", "(", "CmsException", "e", ")", "{", "// ignore", "}", "return", "(", "res", "!=", "null", ")", "&&", "res", ".", "getState", "(", ")", ".", "isDeleted", "(", ")", ";", "}" ]

[ "Checks", "if", "a", "the", "resource", "exists", "but", "is", "marked", "as", "deleted", ".", "<p", ">" ]

[ "public", "static", "Point", "QuadKeyToTileXY", "(", "final", "String", "quadKey", ",", "final", "Point", "reuse", ")", "{", "final", "Point", "out", "=", "reuse", "==", "null", "?", "new", "Point", "(", ")", ":", "reuse", ";", "if", "(", "quadKey", "==", "null", "||", "quadKey", ".", "length", "(", ")", "==", "0", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Invalid QuadKey: \"", "+", "quadKey", ")", ";", "}", "int", "tileX", "=", "0", ";", "int", "tileY", "=", "0", ";", "final", "int", "zoom", "=", "quadKey", ".", "length", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "zoom", ";", "i", "++", ")", "{", "final", "int", "value", "=", "1", "<<", "i", ";", "switch", "(", "quadKey", ".", "charAt", "(", "zoom", "-", "i", "-", "1", ")", ")", "{", "case", "'", "'", ":", "break", ";", "case", "'", "'", ":", "tileX", "+=", "value", ";", "break", ";", "case", "'", "'", ":", "tileY", "+=", "value", ";", "break", ";", "case", "'", "'", ":", "tileX", "+=", "value", ";", "tileY", "+=", "value", ";", "break", ";", "default", ":", "throw", "new", "IllegalArgumentException", "(", "\"Invalid QuadKey: \"", "+", "quadKey", ")", ";", "}", "}", "out", ".", "x", "=", "tileX", ";", "out", ".", "y", "=", "tileY", ";", "return", "out", ";", "}" ]

[ "Use", "{" ]

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

[ "Create", "or", "update", "a", "key", "vault", "in", "the", "specified", "subscription", "." ]

[ "private", "static", "String", "getBase64Data", "(", "BufferedImage", "buffImage", ",", "String", "formatName", ",", "Node", "node", ")", "throws", "Exception", "{", "int", "numBytes", "=", "buffImage", ".", "getWidth", "(", ")", "*", "buffImage", ".", "getHeight", "(", ")", "*", "4", ";", "ByteArrayOutputStream", "baos", "=", "new", "ByteArrayOutputStream", "(", "numBytes", ")", ";", "ImageOutputStream", "ios", "=", "ImageIO", ".", "createImageOutputStream", "(", "baos", ")", ";", "boolean", "status", "=", "ImageIO", ".", "write", "(", "buffImage", ",", "formatName", ",", "ios", ")", ";", "if", "(", "!", "status", ")", "{", "throw", "new", "Exception", "(", "\"No suitable ImageIO writer found by ImageParser.getBase64Data() for image format \"", "+", "formatName", ")", ";", "}", "byte", "[", "]", "imageData", "=", "baos", ".", "toByteArray", "(", ")", ";", "// String base64String = Base64.encodeBase64String(imageData); this is", "// unchunked (no line breaks) which is unwieldy", "byte", "[", "]", "base64Data", "=", "Base64", ".", "encodeBase64Chunked", "(", "imageData", ")", ";", "// 2011-11-15 PwD uncomment for Java 1.7 String base64String = new", "// String(base64Data, StandardCharsets.UTF_8);", "String", "base64String", "=", "new", "String", "(", "base64Data", ",", "\"UTF-8\"", ")", ";", "// 2011-11-15 PwD", "// for Java 1.6;", "// remove for", "// Java 1.7", "return", "base64String", ";", "}" ]

[ "/", "*", "2011", "-", "09", "-", "08", "PwD" ]

[ "public", "static", "float", "Spline", "(", "float", "x", ",", "int", "numKnots", ",", "float", "[", "]", "knots", ")", "{", "int", "span", ";", "int", "numSpans", "=", "numKnots", "-", "3", ";", "float", "k0", ",", "k1", ",", "k2", ",", "k3", ";", "float", "c0", ",", "c1", ",", "c2", ",", "c3", ";", "if", "(", "numSpans", "<", "1", ")", "throw", "new", "IllegalArgumentException", "(", "\"Too few knots in spline\"", ")", ";", "x", "=", "x", ">", "1", "?", "1", ":", "x", ";", "x", "=", "x", "<", "0", "?", "0", ":", "x", ";", "x", "*=", "numSpans", ";", "span", "=", "(", "int", ")", "x", ";", "if", "(", "span", ">", "numKnots", "-", "4", ")", "span", "=", "numKnots", "-", "4", ";", "x", "-=", "span", ";", "k0", "=", "knots", "[", "span", "]", ";", "k1", "=", "knots", "[", "span", "+", "1", "]", ";", "k2", "=", "knots", "[", "span", "+", "2", "]", ";", "k3", "=", "knots", "[", "span", "+", "3", "]", ";", "c3", "=", "-", "0.5f", "*", "k0", "+", "1.5f", "*", "k1", "+", "-", "1.5f", "*", "k2", "+", "0.5f", "*", "k3", ";", "c2", "=", "1f", "*", "k0", "+", "-", "2.5f", "*", "k1", "+", "2f", "*", "k2", "+", "-", "0.5f", "*", "k3", ";", "c1", "=", "-", "0.5f", "*", "k0", "+", "0f", "*", "k1", "+", "0.5f", "*", "k2", "+", "0f", "*", "k3", ";", "c0", "=", "0f", "*", "k0", "+", "1f", "*", "k1", "+", "0f", "*", "k2", "+", "0f", "*", "k3", ";", "return", "(", "(", "c3", "*", "x", "+", "c2", ")", "*", "x", "+", "c1", ")", "*", "x", "+", "c0", ";", "}" ]

[ "compute", "a", "Catmull", "-", "Rom", "spline", "." ]

[ "private", "static", "void", "setFieldValue", "(", "Object", "entity", ",", "Field", "member", ",", "Object", "retVal", ")", "{", "if", "(", "member", "!=", "null", "&&", "retVal", "!=", "null", "&&", "entity", "!=", "null", ")", "{", "PropertyAccessorHelper", ".", "set", "(", "entity", ",", "member", ",", "retVal", ")", ";", "}", "}" ]

[ "Sets", "the", "field", "value", "." ]

[ "private", "static", "void", "_excute", "(", "final", "int", "index", ",", "final", "CancelableCountDownLatch", "counter", ",", "final", "Postcard", "postcard", ")", "{", "if", "(", "index", "<", "Warehouse", ".", "interceptors", ".", "size", "(", ")", ")", "{", "IInterceptor", "iInterceptor", "=", "Warehouse", ".", "interceptors", ".", "get", "(", "index", ")", ";", "iInterceptor", ".", "process", "(", "postcard", ",", "new", "InterceptorCallback", "(", ")", "{", "@", "Override", "public", "void", "onContinue", "(", "Postcard", "postcard", ")", "{", "// Last interceptor excute over with no exception.", "counter", ".", "countDown", "(", ")", ";", "_excute", "(", "index", "+", "1", ",", "counter", ",", "postcard", ")", ";", "// When counter is down, it will be execute continue ,but index bigger than interceptors size, then U know.", "}", "@", "Override", "public", "void", "onInterrupt", "(", "Throwable", "exception", ")", "{", "// Last interceptor excute over with fatal exception.", "postcard", ".", "setTag", "(", "null", "==", "exception", "?", "new", "HandlerException", "(", "\"No message.\"", ")", ":", "exception", ".", "getMessage", "(", ")", ")", ";", "// save the exception message for backup.", "counter", ".", "cancel", "(", ")", ";", "// Be attention, maybe the thread in callback has been changed,", "// then the catch block(L207) will be invalid.", "// The worst is the thread changed to main thread, then the app will be crash, if you throw this exception!", "// if (!Looper.getMainLooper().equals(Looper.myLooper())) { // You shouldn't throw the exception if the thread is main thread.", "// throw new HandlerException(exception.getMessage());", "// }", "}", "}", ")", ";", "}", "}" ]

[ "Excute", "interceptor" ]

[ "public", "static", "<", "T", "extends", "Collection", "<", "String", ">", ">", "T", "findAll", "(", "String", "regex", ",", "CharSequence", "content", ",", "int", "group", ",", "T", "collection", ")", "{", "if", "(", "null", "==", "regex", ")", "{", "return", "collection", ";", "}", "return", "findAll", "(", "Pattern", ".", "compile", "(", "regex", ",", "Pattern", ".", "DOTALL", ")", ",", "content", ",", "group", ",", "collection", ")", ";", "}" ]

[ "取得内容中匹配的所有结果" ]

[ "public", "Object", "getValue", "(", "Map", "<", "String", ",", "Object", ">", "map", ",", "String", "name", ")", "{", "String", "cleanName", "=", "htmlCleaner", ".", "cleanupValue", "(", "name", ")", ";", "return", "getValueImpl", "(", "map", ",", "cleanName", ",", "true", ")", ";", "}" ]

[ "Gets", "value", "from", "map", "." ]

[ "private", "String", "getBasePath", "(", "String", "path1", ",", "String", "path2", ")", "{", "StringBuffer", "base", "=", "new", "StringBuffer", "(", ")", ";", "path1", "=", "path1", ".", "replace", "(", "'", "'", ",", "'", "'", ")", ";", "path2", "=", "path2", ".", "replace", "(", "'", "'", ",", "'", "'", ")", ";", "String", "[", "]", "parts1", "=", "path1", ".", "split", "(", "\"/\"", ")", ";", "String", "[", "]", "parts2", "=", "path2", ".", "split", "(", "\"/\"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "parts1", ".", "length", ";", "i", "++", ")", "{", "if", "(", "i", ">=", "parts2", ".", "length", ")", "{", "break", ";", "}", "if", "(", "parts1", "[", "i", "]", ".", "equals", "(", "parts2", "[", "i", "]", ")", ")", "{", "base", ".", "append", "(", "parts1", "[", "i", "]", "+", "\"/\"", ")", ";", "}", "}", "return", "base", ".", "toString", "(", ")", ";", "}" ]

[ "Compares", "two", "path", "s", "for", "the", "base", "part", "which", "have", "both", "equal", ".", "<p", ">" ]

[ "public", "static", "String", "formatDateStr", "(", "String", "dateStr", ",", "String", "...", "patterns", ")", "{", "String", "pattern", "=", "TIMESTAMP_PATTERN", ";", "if", "(", "patterns", "!=", "null", "&&", "patterns", ".", "length", ">", "0", "&&", "StringUtils", ".", "isNotBlank", "(", "patterns", "[", "0", "]", ")", ")", "{", "pattern", "=", "patterns", "[", "0", "]", ";", "}", "return", "DateFormatUtils", ".", "format", "(", "parseDate", "(", "dateStr", ")", ",", "pattern", ")", ";", "}" ]

[ "格式化日期字符串<br", ">", "generate", "by", ":", "vakin", "jiang", "at", "2012", "-", "3", "-", "7" ]

[ "public", "void", "setLoop", "(", "boolean", "doLoop", ",", "GVRContext", "gvrContext", ")", "{", "if", "(", "this", ".", "loop", "!=", "doLoop", ")", "{", "// a change in the loop", "for", "(", "GVRNodeAnimation", "gvrKeyFrameAnimation", ":", "gvrKeyFrameAnimations", ")", "{", "if", "(", "doLoop", ")", "gvrKeyFrameAnimation", ".", "setRepeatMode", "(", "GVRRepeatMode", ".", "REPEATED", ")", ";", "else", "gvrKeyFrameAnimation", ".", "setRepeatMode", "(", "GVRRepeatMode", ".", "ONCE", ")", ";", "}", "// be sure to start the animations if loop is true", "if", "(", "doLoop", ")", "{", "for", "(", "GVRNodeAnimation", "gvrKeyFrameAnimation", ":", "gvrKeyFrameAnimations", ")", "{", "gvrKeyFrameAnimation", ".", "start", "(", "gvrContext", ".", "getAnimationEngine", "(", ")", ")", ";", "}", "}", "this", ".", "loop", "=", "doLoop", ";", "}", "}" ]

[ "SetLoop", "will", "either", "set", "the", "GVRNodeAnimation", "s", "Repeat", "Mode", "to", "REPEATED", "if", "loop", "is", "true", ".", "or", "it", "will", "set", "the", "GVRNodeAnimation", "s", "Repeat", "Mode", "to", "ONCE", "if", "loop", "is", "false", "if", "loop", "is", "set", "to", "TRUE", "when", "it", "was", "previously", "FALSE", "then", "start", "the", "Animation", "." ]

[ "private", "void", "parseConfig", "(", "Element", "property", ",", "BeanDefinitionBuilder", "propertyBuilder", ")", "{", "Element", "config", "=", "(", "Element", ")", "getTagChildren", "(", "\"config\"", ",", "property", ")", ".", "item", "(", "0", ")", ";", "if", "(", "config", "!=", "null", ")", "{", "Properties", "properties", "=", "new", "Properties", "(", ")", ";", "NodeList", "entries", "=", "getTagChildren", "(", "\"entry\"", ",", "config", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "entries", ".", "getLength", "(", ")", ";", "i", "++", ")", "{", "Element", "entry", "=", "(", "Element", ")", "entries", ".", "item", "(", "i", ")", ";", "String", "key", "=", "entry", ".", "getAttribute", "(", "\"key\"", ")", ";", "String", "value", "=", "entry", ".", "getTextContent", "(", ")", ".", "trim", "(", ")", ";", "properties", ".", "put", "(", "key", ",", "value", ")", ";", "}", "propertyBuilder", ".", "addPropertyValue", "(", "\"config\"", ",", "properties", ")", ";", "}", "}" ]

[ "Parses", "out", "configuration", "settings", "for", "current", "property", "descriptor", "." ]

[ "public", "static", "String", "getQueryStringFromParams", "(", "MultiValueMap", "<", "String", ",", "String", ">", "queryParams", ",", "boolean", "encodeValues", ")", "{", "try", "{", "return", "getQueryStringFromParams", "(", "queryParams", ",", "\"UTF-8\"", ",", "encodeValues", ")", ";", "}", "catch", "(", "UnsupportedEncodingException", "e", ")", "{", "// Should NEVER happen", "throw", "new", "IllegalStateException", "(", "\"UTF-8 should always be supported by the JVM\"", ",", "e", ")", ";", "}", "}" ]

[ "Builds", "a", "query", "string", "from", "the", "specified", "params", ".", "The", "param", "names", "are", "always", "encoded", "but", "the", "values", "are", "only", "encoded", "if", "{", "@code", "encodeValues", "}", "is", "true", ".", "UTF", "-", "8", "is", "used", "as", "the", "encoding", "charset", "." ]

[ "private", "Object", "executeExp", "(", "PageContext", "pc", ",", "SQL", "sql", ",", "Query", "qr", ",", "ZExp", "exp", ",", "int", "row", ")", "throws", "PageException", "{", "if", "(", "exp", "instanceof", "ZConstant", ")", "return", "executeConstant", "(", "sql", ",", "qr", ",", "(", "ZConstant", ")", "exp", ",", "row", ")", ";", "else", "if", "(", "exp", "instanceof", "ZExpression", ")", "return", "executeExpression", "(", "pc", ",", "sql", ",", "qr", ",", "(", "ZExpression", ")", "exp", ",", "row", ")", ";", "throw", "new", "DatabaseException", "(", "\"unsupported sql statement [\"", "+", "exp", "+", "\"]\"", ",", "null", ",", "sql", ",", "null", ")", ";", "}" ]

[ "Executes", "a", "ZEXp" ]

[ "public", "Attachment", "attachFile", "(", "long", "sheetId", ",", "long", "rowId", ",", "InputStream", "inputStream", ",", "String", "contentType", ",", "long", "contentLength", ",", "String", "attachmentName", ")", "throws", "SmartsheetException", "{", "Util", ".", "throwIfNull", "(", "inputStream", ",", "contentType", ")", ";", "return", "super", ".", "attachFile", "(", "\"sheets/\"", "+", "sheetId", "+", "\"/rows/\"", "+", "rowId", "+", "\"/attachments\"", ",", "inputStream", ",", "contentType", ",", "contentLength", ",", "attachmentName", ")", ";", "}" ]

[ "Attach", "file", "for", "simple", "upload", "." ]

[ "public", "Workspace", "copyWorkspace", "(", "long", "workspaceId", ",", "ContainerDestination", "containerDestination", ",", "EnumSet", "<", "WorkspaceCopyInclusion", ">", "includes", ",", "EnumSet", "<", "WorkspaceRemapExclusion", ">", "skipRemap", ")", "throws", "SmartsheetException", "{", "return", "copyWorkspace", "(", "workspaceId", ",", "containerDestination", ",", "includes", ",", "skipRemap", ",", "null", ")", ";", "}" ]

[ "Creates", "a", "copy", "of", "the", "specified", "workspace", "." ]

[ "public", "Epic", "createEpic", "(", "String", "name", ",", "Map", "<", "String", ",", "Object", ">", "attributes", ")", "{", "return", "getInstance", "(", ")", ".", "create", "(", ")", ".", "epic", "(", "name", ",", "this", ",", "attributes", ")", ";", "}" ]

[ "Create", "a", "new", "Epic", "in", "this", "Project", "." ]

[ "private", "void", "putForeignHost", "(", "int", "hostId", ",", "ForeignHost", "fh", ")", "{", "synchronized", "(", "m_mapLock", ")", "{", "m_foreignHosts", "=", "ImmutableMultimap", ".", "<", "Integer", ",", "ForeignHost", ">", "builder", "(", ")", ".", "putAll", "(", "m_foreignHosts", ")", ".", "put", "(", "hostId", ",", "fh", ")", ".", "build", "(", ")", ";", "}", "}" ]

[ "/", "*", "Convenience", "method", "for", "doing", "the", "verbose", "COW", "insert", "into", "the", "map" ]

[ "@", "Override", "protected", "void", "doTransform", "(", "ITransformable", ".", "Alpha", "transformable", ",", "float", "comp", ")", "{", "if", "(", "comp", "<=", "0", ")", "return", ";", "float", "from", "=", "reversed", "?", "toAlpha", ":", "fromAlpha", ";", "float", "to", "=", "reversed", "?", "fromAlpha", ":", "toAlpha", ";", "transformable", ".", "setAlpha", "(", "(", "int", ")", "(", "from", "+", "(", "to", "-", "from", ")", "*", "comp", ")", ")", ";", "}" ]

[ "Calculates", "the", "transformation", "." ]

[ "public", "void", "printCoordinate", "(", "int", "[", "]", "row", ",", "int", "[", "]", "column", ",", "long", "[", "]", "data", ",", "int", "offset", ")", "{", "int", "size", "=", "row", ".", "length", ";", "if", "(", "size", "!=", "column", ".", "length", "||", "size", "!=", "data", ".", "length", ")", "throw", "new", "IllegalArgumentException", "(", "\"All arrays must be of the same size\"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "size", ";", "++", "i", ")", "format", "(", "Locale", ".", "ENGLISH", "", ",", "\"%10d %10d %19d%n\"", ",", "row", "[", "i", "]", "+", "offset", ",", "column", "[", "i", "]", "+", "offset", ",", "data", "[", "i", "]", ")", ";", "}" ]

[ "Prints", "the", "coordinate", "format", "to", "the", "underlying", "stream", ".", "One", "index", "pair", "and", "entry", "on", "each", "line", ".", "The", "offset", "is", "added", "to", "each", "index", "typically", "this", "can", "transform", "from", "a", "0", "-", "based", "indicing", "to", "a", "1", "-", "based", "." ]

[ "public", "static", "GatewayBean", "unmarshallGateway", "(", "Map", "<", "String", ",", "Object", ">", "source", ")", "{", "if", "(", "source", "==", "null", ")", "{", "return", "null", ";", "}", "GatewayBean", "bean", "=", "new", "GatewayBean", "(", ")", ";", "bean", ".", "setId", "(", "asString", "(", "source", ".", "get", "(", "\"id\"", ")", ")", ")", ";", "bean", ".", "setName", "(", "asString", "(", "source", ".", "get", "(", "\"name\"", ")", ")", ")", ";", "bean", ".", "setDescription", "(", "asString", "(", "source", ".", "get", "(", "\"description\"", ")", ")", ")", ";", "bean", ".", "setType", "(", "asEnum", "(", "source", ".", "get", "(", "\"type\"", ")", ",", "GatewayType", ".", "class", ")", ")", ";", "bean", ".", "setConfiguration", "(", "asString", "(", "source", ".", "get", "(", "\"configuration\"", ")", ")", ")", ";", "bean", ".", "setCreatedBy", "(", "asString", "(", "source", ".", "get", "(", "\"createdBy\"", ")", ")", ")", ";", "bean", ".", "setCreatedOn", "(", "asDate", "(", "source", ".", "get", "(", "\"createdOn\"", ")", ")", ")", ";", "bean", ".", "setModifiedBy", "(", "asString", "(", "source", ".", "get", "(", "\"modifiedBy\"", ")", ")", ")", ";", "bean", ".", "setModifiedOn", "(", "asDate", "(", "source", ".", "get", "(", "\"modifiedOn\"", ")", ")", ")", ";", "postMarshall", "(", "bean", ")", ";", "return", "bean", ";", "}" ]

[ "Unmarshals", "the", "given", "map", "source", "into", "a", "bean", "." ]

[ "public", "RendererJob", "otherTile", "(", "Tile", "tile", ")", "{", "return", "new", "RendererJob", "(", "tile", ",", "this", ".", "mapDataStore", ",", "this", ".", "renderThemeFuture", ",", "this", ".", "displayModel", ",", "this", ".", "textScale", ",", "this", ".", "hasAlpha", ",", "this", ".", "labelsOnly", ")", ";", "}" ]

[ "Just", "a", "way", "of", "generating", "a", "hash", "key", "for", "a", "tile", "if", "only", "the", "RendererJob", "is", "known", "." ]

[ "public", "String", "postJson", "(", "String", "endpoint", ",", "JSONObject", "json", ")", "throws", "IOException", "{", "return", "this", ".", "postJson", "(", "endpoint", ",", "\"\"", ",", "json", ")", ";", "}" ]

[ "Issues", "HTTP", "POST", "request", "returns", "response", "body", "as", "string", "." ]

[ "public", "Observable", "<", "Void", ">", "startAsync", "(", "String", "groupName", ",", "String", "serviceName", ")", "{", "return", "startWithServiceResponseAsync", "(", "groupName", ",", "serviceName", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "Void", ">", ",", "Void", ">", "(", ")", "{", "@", "Override", "public", "Void", "call", "(", "ServiceResponse", "<", "Void", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Start", "service", ".", "The", "services", "resource", "is", "the", "top", "-", "level", "resource", "that", "represents", "the", "Data", "Migration", "Service", ".", "This", "action", "starts", "the", "service", "and", "the", "service", "can", "be", "used", "for", "data", "migration", "." ]

[ "public", "Observable", "<", "ServiceResponse", "<", "Page", "<", "LongTermRetentionBackupInner", ">", ">", ">", "listByServerWithServiceResponseAsync", "(", "final", "String", "locationName", ",", "final", "String", "longTermRetentionServerName", ",", "final", "Boolean", "onlyLatestPerDatabase", ",", "final", "LongTermRetentionDatabaseState", "databaseState", ")", "{", "return", "listByServerSinglePageAsync", "(", "locationName", ",", "longTermRetentionServerName", ",", "onlyLatestPerDatabase", ",", "databaseState", ")", ".", "concatMap", "(", "new", "Func1", "<", "ServiceResponse", "<", "Page", "<", "LongTermRetentionBackupInner", ">", ">", ",", "Observable", "<", "ServiceResponse", "<", "Page", "<", "LongTermRetentionBackupInner", ">", ">", ">", ">", "(", ")", "{", "@", "Override", "public", "Observable", "<", "ServiceResponse", "<", "Page", "<", "LongTermRetentionBackupInner", ">", ">", ">", "call", "(", "ServiceResponse", "<", "Page", "<", "LongTermRetentionBackupInner", ">", ">", "page", ")", "{", "String", "nextPageLink", "=", "page", ".", "body", "(", ")", ".", "nextPageLink", "(", ")", ";", "if", "(", "nextPageLink", "==", "null", ")", "{", "return", "Observable", ".", "just", "(", "page", ")", ";", "}", "return", "Observable", ".", "just", "(", "page", ")", ".", "concatWith", "(", "listByServerNextWithServiceResponseAsync", "(", "nextPageLink", ")", ")", ";", "}", "}", ")", ";", "}" ]

[ "Lists", "the", "long", "term", "retention", "backups", "for", "a", "given", "server", "." ]

[ "private", "static", "void", "assertArrayLength", "(", "final", "int", "length", ",", "final", "JBBPNamedFieldInfo", "name", ")", "{", "if", "(", "length", "<", "0", ")", "{", "throw", "new", "JBBPParsingException", "(", "\"Detected negative calculated array length for field '\"", "+", "(", "name", "==", "null", "?", "\"<NO NAME>\"", ":", "name", ".", "getFieldPath", "(", ")", ")", "+", "\"\\' [\"", "+", "JBBPUtils", ".", "int2msg", "(", "length", ")", "+", "'", "'", ")", ";", "}", "}" ]

[ "Ensure", "that", "an", "array", "length", "is", "not", "a", "negative", "one", "." ]

[ "public", "void", "setDictionary", "(", "byte", "[", "]", "b", ",", "int", "off", ",", "int", "len", ")", "{", "if", "(", "b", "==", "null", ")", "{", "throw", "new", "NullPointerException", "(", ")", ";", "}", "if", "(", "off", "<", "0", "||", "len", "<", "0", "||", "off", ">", "b", ".", "length", "-", "len", ")", "{", "throw", "new", "ArrayIndexOutOfBoundsException", "(", ")", ";", "}", "synchronized", "(", "zsRef", ")", "{", "ensureOpen", "(", ")", ";", "setDictionary", "(", "zsRef", ".", "address", "(", ")", ",", "b", ",", "off", ",", "len", ")", ";", "}", "}" ]

[ "Sets", "preset", "dictionary", "for", "compression", ".", "A", "preset", "dictionary", "is", "used", "when", "the", "history", "buffer", "can", "be", "predetermined", ".", "When", "the", "data", "is", "later", "uncompressed", "with", "Inflater", ".", "inflate", "()", "Inflater", ".", "getAdler", "()", "can", "be", "called", "in", "order", "to", "get", "the", "Adler", "-", "32", "value", "of", "the", "dictionary", "required", "for", "decompression", "." ]

[ "public", "void", "setBooleanIfNotNull", "(", "@", "NotNull", "final", "String", "key", ",", "@", "Nullable", "final", "Boolean", "value", ")", "{", "if", "(", "null", "!=", "value", ")", "{", "setBoolean", "(", "key", ",", "value", ")", ";", "}", "}" ]

[ "Sets", "a", "property", "value", "only", "if", "the", "value", "is", "not", "null", "." ]

[ "public", "void", "matchSet", "(", "String", "[", "]", "ElementNames", ",", "String", "[", "]", "ElementValues", ",", "int", "op", ")", "throws", "DBException", "{", "// Delete the old search filter\r", "m_filter", "=", "null", ";", "// If this is not a logical operator, throw an exception\r", "if", "(", "(", "op", "&", "LOGICAL_OPER_MASK", ")", "==", "0", ")", "{", "throw", "new", "DBException", "(", ")", ";", "// Create a vector that will hold the leaf nodes for all elements in the hashtable\r", "}", "Vector", "leafVector", "=", "new", "Vector", "(", ")", ";", "// For each of the elements in the array, create a leaf node for the match\r", "int", "numnames", "=", "ElementNames", ".", "length", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "numnames", ";", "i", "++", ")", "{", "// Create a leaf node for this list and store it as the filter\r", "SearchBaseLeaf", "leafnode", "=", "new", "SearchBaseLeaf", "(", "ElementNames", "[", "i", "]", ",", "IN", ",", "ElementValues", "[", "i", "]", ")", ";", "// Add this leaf node to the vector\r", "leafVector", ".", "addElement", "(", "leafnode", ")", ";", "}", "// Now return a node that holds this set of leaf nodes\r", "m_filter", "=", "new", "SearchBaseNode", "(", "op", ",", "leafVector", ")", ";", "}" ]

[ "Change", "the", "search", "filter", "to", "one", "that", "specifies", "a", "set", "of", "elements", "and", "their", "values", "that", "must", "match", "and", "the", "operator", "to", "use", "to", "combine", "the", "elements", ".", "Each", "element", "name", "is", "compared", "for", "an", "equal", "match", "to", "the", "value", "and", "all", "comparisons", "are", "combined", "by", "the", "specified", "logical", "operator", "(", "OR", "or", "AND", ")", ".", "The", "old", "search", "filter", "is", "deleted", "." ]

[ "public", "static", "AuditEntryBean", "organizationCreated", "(", "OrganizationBean", "bean", ",", "ISecurityContext", "securityContext", ")", "{", "AuditEntryBean", "entry", "=", "newEntry", "(", "bean", ".", "getId", "(", ")", ",", "AuditEntityType", ".", "Organization", ",", "securityContext", ")", ";", "entry", ".", "setEntityId", "(", "null", ")", ";", "entry", ".", "setEntityVersion", "(", "null", ")", ";", "entry", ".", "setWhat", "(", "AuditEntryType", ".", "Create", ")", ";", "return", "entry", ";", "}" ]

[ "Creates", "an", "{" ]

[ "public", "static", "<", "T", "extends", "Levenshtein", ">", "T", "sorensenDice", "(", "String", "baseTarget", ",", "String", "compareTarget", ")", "{", "return", "sorensenDice", "(", "baseTarget", ",", "compareTarget", ",", "null", ")", ";", "}" ]

[ "Returns", "a", "new", "Sorensen", "-", "Dice", "coefficient", "instance", "with", "compare", "target", "string" ]

[ "public", "void", "billingAccount_voicemail_serviceName_settings_changePassword_POST", "(", "String", "billingAccount", ",", "String", "serviceName", ",", "String", "password", ")", "throws", "IOException", "{", "String", "qPath", "=", "\"/telephony/{billingAccount}/voicemail/{serviceName}/settings/changePassword\"", ";", "StringBuilder", "sb", "=", "path", "(", "qPath", ",", "billingAccount", ",", "serviceName", ")", ";", "HashMap", "<", "String", ",", "Object", ">", "o", "=", "new", "HashMap", "<", "String", ",", "Object", ">", "(", ")", ";", "addBody", "(", "o", ",", "\"password\"", ",", "password", ")", ";", "exec", "(", "qPath", ",", "\"POST\"", ",", "sb", ".", "toString", "(", ")", ",", "o", ")", ";", "}" ]

[ "Change", "the", "voicemail", "password", ".", "It", "must", "be", "4", "digit" ]

[ "private", "void", "writeJobState", "(", "JsonWriter", "jsonWriter", ",", "JobState", "jobState", ")", "throws", "IOException", "{", "jobState", ".", "toJson", "(", "jsonWriter", ",", "this", ".", "keepConfig", ")", ";", "}" ]

[ "Write", "a", "single", "{", "@link", "JobState", "}", "to", "json", "document", "." ]

[ "public", "void", "waitForConnectedAndDeflectorHealthy", "(", "long", "timeout", ",", "TimeUnit", "unit", ")", "throws", "InterruptedException", ",", "TimeoutException", "{", "LOG", ".", "debug", "(", "\"Waiting until the write-active index is healthy again, checking once per second.\"", ")", ";", "final", "CountDownLatch", "latch", "=", "new", "CountDownLatch", "(", "1", ")", ";", "final", "ScheduledFuture", "<", "?", ">", "scheduledFuture", "=", "scheduler", ".", "scheduleAtFixedRate", "(", "(", ")", "->", "{", "try", "{", "if", "(", "isConnected", "(", ")", "&&", "isDeflectorHealthy", "(", ")", ")", "{", "LOG", ".", "debug", "(", "\"Write-active index is healthy again, unblocking waiting threads.\"", ")", ";", "latch", ".", "countDown", "(", ")", ";", "}", "}", "catch", "(", "Exception", "ignore", ")", "{", "}", "// to not cancel the schedule", "}", ",", "0", ",", "1", ",", "TimeUnit", ".", "SECONDS", ")", ";", "// TODO should this be configurable?", "final", "boolean", "waitSuccess", "=", "latch", ".", "await", "(", "timeout", ",", "unit", ")", ";", "scheduledFuture", ".", "cancel", "(", "true", ")", ";", "// Make sure to cancel the task to avoid task leaks!", "if", "(", "!", "waitSuccess", ")", "{", "throw", "new", "TimeoutException", "(", "\"Write-active index didn't get healthy within timeout\"", ")", ";", "}", "}" ]

[ "Blocks", "until", "the", "Elasticsearch", "cluster", "and", "current", "write", "index", "is", "healthy", "again", "or", "the", "given", "timeout", "fires", "." ]

[ "void", "checkTopicPublishPermission", "(", "String", "topic", ")", "{", "SecurityManager", "sm", "=", "System", ".", "getSecurityManager", "(", ")", ";", "if", "(", "sm", "==", "null", ")", "return", ";", "sm", ".", "checkPermission", "(", "new", "TopicPermission", "(", "topic", ",", "PUBLISH", ")", ")", ";", "}" ]

[ "Check", "if", "the", "caller", "has", "permission", "to", "publish", "events", "to", "the", "specified", "topic", "." ]

[ "public", "static", "LightweightTypeReference", "toLightweightTypeReference", "(", "JvmTypeReference", "typeRef", ",", "CommonTypeComputationServices", "services", ",", "boolean", "keepUnboundWildcardInformation", ")", "{", "if", "(", "typeRef", "==", "null", ")", "{", "return", "null", ";", "}", "final", "StandardTypeReferenceOwner", "owner", "=", "new", "StandardTypeReferenceOwner", "(", "services", ",", "typeRef", ")", ";", "final", "LightweightTypeReferenceFactory", "factory", "=", "new", "LightweightTypeReferenceFactory", "(", "owner", ",", "keepUnboundWildcardInformation", ")", ";", "final", "LightweightTypeReference", "reference", "=", "factory", ".", "toLightweightReference", "(", "typeRef", ")", ";", "return", "reference", ";", "}" ]

[ "Convert", "a", "type", "reference", "to", "a", "lightweight", "type", "reference", "." ]

[ "@", "Override", "public", "AudioFileFormat", "getAudioFileFormat", "(", "InputStream", "inputStream", ")", "throws", "UnsupportedAudioFileException", ",", "IOException", "{", "LOG", ".", "log", "(", "Level", ".", "FINE", ",", "\"TAudioFileReader.getAudioFileFormat(InputStream): begin (class: {0})\"", ",", "getClass", "(", ")", ".", "getSimpleName", "(", ")", ")", ";", "long", "lFileLengthInBytes", "=", "AudioSystem", ".", "NOT_SPECIFIED", ";", "if", "(", "!", "inputStream", ".", "markSupported", "(", ")", ")", "{", "inputStream", "=", "new", "BufferedInputStream", "(", "inputStream", ",", "getMarkLimit", "(", ")", ")", ";", "}", "inputStream", ".", "mark", "(", "getMarkLimit", "(", ")", ")", ";", "AudioFileFormat", "audioFileFormat", ";", "try", "{", "audioFileFormat", "=", "getAudioFileFormat", "(", "inputStream", ",", "lFileLengthInBytes", ")", ";", "}", "finally", "{", "/* TODO: required semantics is unclear: should reset()\n be executed only when there is an exception or\n should it be done always?\n */", "inputStream", ".", "reset", "(", ")", ";", "}", "LOG", ".", "log", "(", "Level", ".", "FINE", ",", "\"TAudioFileReader.getAudioFileFormat(InputStream): end\"", ")", ";", "return", "audioFileFormat", ";", "}" ]

[ "Get", "an", "AudioFileFormat", "object", "for", "an", "InputStream", ".", "This", "method", "calls", "getAudioFileFormat", "(", "InputStream", "long", ")", ".", "Subclasses", "should", "not", "override", "this", "method", "unless", "there", "are", "really", "severe", "reasons", ".", "Normally", "it", "is", "sufficient", "to", "implement", "getAudioFileFormat", "(", "InputStream", "long", ")", "." ]

[ "@", "DELETE", "@", "Produces", "(", "MediaType", ".", "APPLICATION_JSON", ")", "@", "Path", "(", "\"/{alertId}\"", ")", "@", "Description", "(", "\"Deletes the alert having the given ID along with all its triggers and notifications.\"", ")", "public", "Response", "deleteAlert", "(", "@", "Context", "HttpServletRequest", "req", ",", "@", "PathParam", "(", "\"alertId\"", ")", "BigInteger", "alertId", ")", "{", "if", "(", "alertId", "==", "null", "||", "alertId", ".", "compareTo", "(", "BigInteger", ".", "ZERO", ")", "<", "1", ")", "{", "throw", "new", "WebApplicationException", "(", "\"Alert Id cannot be null and must be a positive non-zero number.\"", ",", "Status", ".", "BAD_REQUEST", ")", ";", "}", "Alert", "alert", "=", "alertService", ".", "findAlertByPrimaryKey", "(", "alertId", ")", ";", "if", "(", "alert", "!=", "null", ")", "{", "validateResourceAuthorization", "(", "req", ",", "alert", ".", "getOwner", "(", ")", ",", "getRemoteUser", "(", "req", ")", ")", ";", "alertService", ".", "markAlertForDeletion", "(", "alert", ")", ";", "return", "Response", ".", "status", "(", "Status", ".", "OK", ")", ".", "build", "(", ")", ";", "}", "throw", "new", "WebApplicationException", "(", "Response", ".", "Status", ".", "NOT_FOUND", ".", "getReasonPhrase", "(", ")", ",", "Response", ".", "Status", ".", "NOT_FOUND", ")", ";", "}" ]

[ "Deletes", "the", "alert", "." ]

[ "public", "static", "Date", "setYears", "(", "final", "Date", "date", ",", "final", "int", "amount", ")", "{", "return", "set", "(", "date", ",", "Calendar", ".", "YEAR", ",", "amount", ")", ";", "}" ]

[ "Sets", "the", "years", "field", "to", "a", "date", "returning", "a", "new", "object", ".", "The", "original", "{", "@code", "Date", "}", "is", "unchanged", "." ]

[ "public", "static", "void", "checkAndWarn", "(", "String", "namespace", ",", "String", "datasetName", ",", "Schema", "schema", ")", "{", "try", "{", "checkDatasetName", "(", "namespace", ",", "datasetName", ")", ";", "checkSchema", "(", "schema", ")", ";", "}", "catch", "(", "IllegalArgumentException", "e", ")", "{", "LOG", ".", "warn", "(", "e", ".", "getMessage", "(", ")", ")", ";", "}", "catch", "(", "IllegalStateException", "e", ")", "{", "LOG", ".", "warn", "(", "e", ".", "getMessage", "(", ")", ")", ";", "}", "}" ]

[ "Checks", "the", "name", "and", "schema", "for", "known", "compatibility", "issues", "and", "warns", "." ]

[ "private", "void", "parseString", "(", "final", "String", "eventSerialized", ")", "{", "final", "StringTokenizer", "st", "=", "new", "StringTokenizer", "(", "eventSerialized", ",", "ClassUtility", ".", "SEPARATOR", ")", ";", "if", "(", "st", ".", "countTokens", "(", ")", ">=", "5", ")", "{", "sequence", "(", "Integer", ".", "parseInt", "(", "st", ".", "nextToken", "(", ")", ")", ")", ".", "eventType", "(", "JRebirthEventType", ".", "valueOf", "(", "st", ".", "nextToken", "(", ")", ")", ")", ".", "source", "(", "st", ".", "nextToken", "(", ")", ")", ".", "target", "(", "st", ".", "nextToken", "(", ")", ")", ".", "eventData", "(", "st", ".", "nextToken", "(", ")", ")", ";", "}", "}" ]

[ "Parse", "the", "serialized", "string", "." ]

[ "public", "QueryParameters", "updateType", "(", "String", "key", ",", "Integer", "type", ")", "{", "this", ".", "types", ".", "put", "(", "processKey", "(", "key", ")", ",", "type", ")", ";", "return", "this", ";", "}" ]

[ "Updates", "type", "of", "specified", "key" ]

[ "private", "boolean", "checkCDataEnd", "(", "char", "[", "]", "outBuf", ",", "int", "outPtr", ")", "throws", "XMLStreamException", "{", "int", "bracketCount", "=", "0", ";", "char", "c", ";", "do", "{", "++", "bracketCount", ";", "c", "=", "(", "mInputPtr", "<", "mInputEnd", ")", "?", "mInputBuffer", "[", "mInputPtr", "++", "]", ":", "getNextCharFromCurrent", "(", "SUFFIX_IN_CDATA", ")", ";", "}", "while", "(", "c", "==", "'", "'", ")", ";", "boolean", "match", "=", "(", "bracketCount", ">=", "2", "&&", "c", "==", "'", "'", ")", ";", "if", "(", "match", ")", "{", "bracketCount", "-=", "2", ";", "}", "while", "(", "bracketCount", ">", "0", ")", "{", "--", "bracketCount", ";", "outBuf", "[", "outPtr", "++", "]", "=", "'", "'", ";", "if", "(", "outPtr", ">=", "outBuf", ".", "length", ")", "{", "/* Can't really easily return, even if we have enough\n * stuff here, since we've more than one char...\n */", "outBuf", "=", "mTextBuffer", ".", "finishCurrentSegment", "(", ")", ";", "outPtr", "=", "0", ";", "}", "}", "mTextBuffer", ".", "setCurrentLength", "(", "outPtr", ")", ";", "// Match? Can break, then:", "if", "(", "match", ")", "{", "return", "true", ";", "}", "// No match, need to push the last char back and admit defeat...", "--", "mInputPtr", ";", "return", "false", ";", "}" ]

[ "Method", "that", "will", "check", "given", "the", "starting", "]", "whether", "there", "is", "ending", "]]", ">", "(", "including", "optional", "extra", "]", "s", ")", ";", "if", "so", "will", "updated", "output", "buffer", "with", "extra", "]", "s", "if", "not", "will", "make", "sure", "input", "and", "output", "are", "positioned", "for", "further", "checking", "." ]

[ "public", "IoTSetResponse", "setUsingIq", "(", "FullJid", "jid", ",", "SetData", "data", ")", "throws", "NoResponseException", ",", "XMPPErrorException", ",", "NotConnectedException", ",", "InterruptedException", "{", "return", "setUsingIq", "(", "jid", ",", "Collections", ".", "singleton", "(", "data", ")", ")", ";", "}" ]

[ "Control", "a", "thing", "by", "sending", "a", "collection", "of", "{", "@link", "SetData", "}", "instructions", "." ]

[ "public", "static", "void", "main", "(", "String", "[", "]", "args", ")", "{", "List", "<", "String", ">", "list", ";", "List", "<", "String", ">", "packages", ";", "int", "i", ";", "StringTokenizer", "tok", ";", "if", "(", "(", "args", ".", "length", "==", "1", ")", "&&", "(", "args", "[", "0", "]", ".", "equals", "(", "\"packages\"", ")", ")", ")", "{", "list", "=", "getSingleton", "(", ")", ".", "findPackages", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "list", ".", "size", "(", ")", ";", "i", "++", ")", "System", ".", "out", ".", "println", "(", "list", ".", "get", "(", "i", ")", ")", ";", "}", "else", "if", "(", "args", ".", "length", "==", "2", ")", "{", "// packages", "packages", "=", "new", "ArrayList", "<>", "(", ")", ";", "tok", "=", "new", "StringTokenizer", "(", "args", "[", "1", "]", ",", "\",\"", ")", ";", "while", "(", "tok", ".", "hasMoreTokens", "(", ")", ")", "packages", ".", "add", "(", "tok", ".", "nextToken", "(", ")", ")", ";", "// search", "list", "=", "getSingleton", "(", ")", ".", "findNames", "(", "args", "[", "0", "]", ",", "packages", ".", "toArray", "(", "new", "String", "[", "packages", ".", "size", "(", ")", "]", ")", ")", ";", "// print result, if any", "System", ".", "out", ".", "println", "(", "\"Searching for '\"", "+", "args", "[", "0", "]", "+", "\"' in '\"", "+", "args", "[", "1", "]", "+", "\"':\\n\"", "+", "\" \"", "+", "list", ".", "size", "(", ")", "+", "\" found.\"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "list", ".", "size", "(", ")", ";", "i", "++", ")", "System", ".", "out", ".", "println", "(", "\" \"", "+", "(", "i", "+", "1", ")", "+", "\". \"", "+", "list", ".", "get", "(", "i", ")", ")", ";", "}", "else", "{", "System", ".", "out", ".", "println", "(", "\"\\nUsage:\"", ")", ";", "System", ".", "out", ".", "println", "(", "ClassLocator", ".", "class", ".", "getName", "(", ")", "+", "\" packages\"", ")", ";", "System", ".", "out", ".", "println", "(", "\"\\tlists all packages in the classpath\"", ")", ";", "System", ".", "out", ".", "println", "(", "ClassLocator", ".", "class", ".", "getName", "(", ")", "+", "\" <classname> <packagename(s)>\"", ")", ";", "System", ".", "out", ".", "println", "(", "\"\\tlists classes derived from/implementing 'classname' that\"", ")", ";", "System", ".", "out", ".", "println", "(", "\"\\tcan be found in 'packagename(s)' (comma-separated list)\"", ")", ";", "System", ".", "out", ".", "println", "(", ")", ";", "System", ".", "exit", "(", "1", ")", ";", "}", "}" ]

[ "Possible", "calls", ":", "<ul", ">", "<li", ">", "adams", ".", "core", ".", "ClassLocator", "&lt", ";", "packages&gt", ";", "<br", ">", "Prints", "all", "the", "packages", "in", "the", "current", "classpath", "<", "/", "li", ">", "<li", ">", "adams", ".", "core", ".", "ClassLocator", "&lt", ";", "classname&gt", ";", "&lt", ";", "packagename", "(", "s", ")", "&gt", ";", "<br", ">", "Prints", "the", "classes", "it", "found", ".", "<", "/", "li", ">", "<", "/", "ul", ">" ]

[ "private", "void", "maybeAddAliasToSymbolTable", "(", "Node", "n", ",", "String", "module", ")", "{", "if", "(", "preprocessorSymbolTable", "!=", "null", ")", "{", "n", ".", "putBooleanProp", "(", "Node", ".", "MODULE_ALIAS", ",", "true", ")", ";", "// Alias can be used in js types. Types have node type STRING and not NAME so we have to", "// use their name as string.", "String", "nodeName", "=", "n", ".", "getToken", "(", ")", "==", "Token", ".", "STRING", "?", "n", ".", "getString", "(", ")", ":", "preprocessorSymbolTable", ".", "getQualifiedName", "(", "n", ")", ";", "// We need to include module as part of the name because aliases are local to current module.", "// Aliases with the same name from different module should be completely different entities.", "String", "name", "=", "\"alias_\"", "+", "module", "+", "\"_\"", "+", "nodeName", ";", "preprocessorSymbolTable", ".", "addReference", "(", "n", ",", "name", ")", ";", "}", "}" ]

[ "Add", "alias", "nodes", "to", "the", "symbol", "table", "as", "they", "going", "to", "be", "removed", "by", "rewriter", ".", "Example", "aliases", ":" ]

[ "@", "SafeVarargs", "public", "static", "<", "T", ">", "Stream", "<", "List", "<", "T", ">", ">", "mergeToList", "(", "Stream", "<", "T", ">", "...", "streams", ")", "{", "return", "merge", "(", "ArrayList", "::", "new", ",", "(", "l", ",", "x", ")", "->", "{", "l", ".", "add", "(", "x", ")", ";", "return", "l", ";", "}", ",", "streams", ")", ";", "}" ]

[ "Construct", "a", "stream", "which", "merges", "together", "values", "from", "the", "supplied", "streams", "into", "lists", "of", "values", "somewhat", "in", "the", "manner", "of", "the", "stream", "constructed", "by", "{", "@link", "com", ".", "codepoetics", ".", "protonpack", ".", "StreamUtils#zip", "(", "java", ".", "util", ".", "stream", ".", "Stream", "java", ".", "util", ".", "stream", ".", "Stream", "java", ".", "util", ".", "function", ".", "BiFunction", ")", "}", "but", "for", "an", "arbitrary", "number", "of", "streams", "." ]

[ "public", "static", "List", "<", "ComponentWithContext", ">", "findComponentsByClass", "(", "final", "WComponent", "root", ",", "final", "String", "className", ")", "{", "return", "findComponentsByClass", "(", "root", ",", "className", ",", "true", ",", "true", ")", ";", "}" ]

[ "Search", "for", "components", "implementing", "a", "particular", "class", "name", ".", "<p", ">", "Only", "search", "visible", "components", "and", "include", "the", "root", "component", "in", "the", "matching", "logic", ".", "<", "/", "p", ">" ]

[ "boolean", "setToken", "(", "char", "token", "[", "]", ",", "byte", "tokenstring", "[", "]", ")", "{", "if", "(", "token", "!=", "null", "&&", "tokenstring", "!=", "null", "&&", "token", ".", "length", ">", "0", "&&", "tokenstring", ".", "length", ">", "0", ")", "{", "m_tokentable_", "=", "token", ";", "m_tokenstring_", "=", "tokenstring", ";", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Sets", "the", "token", "data" ]

[ "private", "boolean", "canBeMerged", "(", "DenseRange", "<", "T", ">", "current", ",", "DenseRange", "<", "T", ">", "next", ")", "{", "return", "Order", ".", "of", "(", "comparator", ",", "current", ".", "end", "(", ")", ",", "Optional", ".", "of", "(", "next", ".", "begin", "(", ")", ")", ")", "==", "Order", ".", "EQ", "||", "current", ".", "overlaps", "(", "next", ")", ";", "}" ]

[ "<code", ">", "|", "-----------", "|", "|", "-----", "|", "<", "/", "code", ">", "or", "<code", ">", "|", "-----------", "|", "|", "------", "|", "<", "/", "code", ">" ]

[ "public", "void", "writeBytes", "(", "byte", "[", "]", "data", ",", "int", "offset", ",", "int", "length", ")", "throws", "IOException", "{", "prepareValue", "(", ")", ";", "updateLength", "(", "length", ")", ";", "buffer", ".", "writeBytes", "(", "data", ",", "offset", ",", "length", ")", ";", "finishValue", "(", ")", ";", "}" ]

[ "Writes", "a", "raw", "value", "into", "the", "buffer", "updating", "lengths", "appropriately", ".", "<p", ">", "The", "implication", "here", "is", "that", "the", "caller", "is", "dumping", "some", "valid", "Ion", "payload", "with", "the", "correct", "context", "." ]

[ "public", "boolean", "hasContact", "(", "ResidueIdentifier", "resId1", ",", "ResidueIdentifier", "resId2", ")", "{", "return", "contacts", ".", "containsKey", "(", "new", "Pair", "<", "ResidueIdentifier", ">", "(", "resId1", ",", "resId2", ")", ")", ";", "}" ]

[ "Tell", "whether", "the", "given", "pair", "is", "a", "contact", "in", "this", "GroupContactSet", "in", "a", "chain", "-", "identifier", "independent", "way", ":", "contacts", "happening", "between", "different", "copies", "of", "the", "same", "Compound", "(", "Entity", ")", "will", "be", "considered", "equal", "as", "long", "as", "they", "have", "the", "same", "residue", "numbers", "." ]

[ "protected", "void", "addPartialInfo", "(", "ClassDoc", "cd", ",", "Content", "contentTree", ")", "{", "addPreQualifiedStrongClassLink", "(", "LinkInfoImpl", ".", "Kind", ".", "TREE", ",", "cd", ",", "contentTree", ")", ";", "}" ]

[ "Add", "information", "about", "the", "class", "kind", "if", "it", "s", "a", "class", "or", "interface", "." ]

[ "@", "Override", "public", "CommerceOrder", "removeByUUID_G", "(", "String", "uuid", ",", "long", "groupId", ")", "throws", "NoSuchOrderException", "{", "CommerceOrder", "commerceOrder", "=", "findByUUID_G", "(", "uuid", ",", "groupId", ")", ";", "return", "remove", "(", "commerceOrder", ")", ";", "}" ]

[ "Removes", "the", "commerce", "order", "where", "uuid", "=", "&#63", ";", "and", "groupId", "=", "&#63", ";", "from", "the", "database", "." ]

[ "public", "Observable", "<", "UserInner", ">", "createOrUpdateAsync", "(", "String", "resourceGroupName", ",", "String", "labAccountName", ",", "String", "labName", ",", "String", "userName", ",", "UserInner", "user", ")", "{", "return", "createOrUpdateWithServiceResponseAsync", "(", "resourceGroupName", ",", "labAccountName", ",", "labName", ",", "userName", ",", "user", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "UserInner", ">", ",", "UserInner", ">", "(", ")", "{", "@", "Override", "public", "UserInner", "call", "(", "ServiceResponse", "<", "UserInner", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Create", "or", "replace", "an", "existing", "User", "." ]

[ "private", "int", "doWriteMultiple", "(", "ChannelOutboundBuffer", "in", ")", "throws", "Exception", "{", "final", "long", "maxBytesPerGatheringWrite", "=", "config", "(", ")", ".", "getMaxBytesPerGatheringWrite", "(", ")", ";", "IovArray", "array", "=", "(", "(", "EpollEventLoop", ")", "eventLoop", "(", ")", ")", ".", "cleanIovArray", "(", ")", ";", "array", ".", "maxBytes", "(", "maxBytesPerGatheringWrite", ")", ";", "in", ".", "forEachFlushedMessage", "(", "array", ")", ";", "if", "(", "array", ".", "count", "(", ")", ">=", "1", ")", "{", "// TODO: Handle the case where cnt == 1 specially.", "return", "writeBytesMultiple", "(", "in", ",", "array", ")", ";", "}", "// cnt == 0, which means the outbound buffer contained empty buffers only.", "in", ".", "removeBytes", "(", "0", ")", ";", "return", "0", ";", "}" ]

[ "Attempt", "to", "write", "multiple", "{" ]

[ "public", "static", "void", "notNullOrEmpty", "(", "final", "String", "string", ",", "final", "String", "message", ")", "throws", "IllegalArgumentException", "{", "if", "(", "string", "==", "null", "||", "string", ".", "length", "(", ")", "==", "0", ")", "{", "throw", "new", "IllegalArgumentException", "(", "message", ")", ";", "}", "}" ]

[ "Checks", "that", "the", "specified", "String", "is", "not", "null", "or", "empty", "throws", "exception", "if", "it", "is", "." ]

[ "public", "SourceLocation", "extend", "(", "int", "lines", ",", "int", "cols", ")", "{", "return", "new", "SourceLocation", "(", "filePath", ",", "begin", ",", "end", ".", "offset", "(", "lines", ",", "cols", ")", ")", ";", "}" ]

[ "Returns", "a", "new", "SourceLocation", "that", "starts", "where", "this", "SourceLocation", "starts", "and", "ends", "{" ]

[ "private", "void", "populateMemberData", "(", "MPPReader", "reader", ",", "ProjectFile", "file", ",", "DirectoryEntry", "root", ")", "throws", "IOException", "{", "m_reader", "=", "reader", ";", "m_root", "=", "root", ";", "m_file", "=", "file", ";", "m_eventManager", "=", "file", ".", "getEventManager", "(", ")", ";", "m_calendarMap", "=", "new", "HashMap", "<", "Integer", ",", "ProjectCalendar", ">", "(", ")", ";", "m_projectDir", "=", "(", "DirectoryEntry", ")", "root", ".", "getEntry", "(", "\" 1\"", ")", ";", "m_viewDir", "=", "(", "DirectoryEntry", ")", "root", ".", "getEntry", "(", "\" 2\"", ")", ";", "m_file", ".", "getProjectProperties", "(", ")", ".", "setMppFileType", "(", "Integer", ".", "valueOf", "(", "8", ")", ")", ";", "}" ]

[ "Populate", "member", "data", "used", "by", "the", "rest", "of", "the", "reader", "." ]

[ "protected", "void", "checkElementPresence", "(", "PageElement", "pageElement", ",", "boolean", "present", ")", "throws", "FailureException", "{", "if", "(", "present", ")", "{", "try", "{", "Context", ".", "waitUntil", "(", "ExpectedConditions", ".", "presenceOfElementLocated", "(", "Utilities", ".", "getLocator", "(", "pageElement", ")", ")", ")", ";", "}", "catch", "(", "final", "Exception", "e", ")", "{", "new", "Result", ".", "Failure", "<>", "(", "e", ".", "getMessage", "(", ")", ",", "Messages", ".", "getMessage", "(", "Messages", ".", "FAIL_MESSAGE_UNABLE_TO_FIND_ELEMENT", ")", ",", "true", ",", "pageElement", ".", "getPage", "(", ")", ".", "getCallBack", "(", ")", ")", ";", "}", "}", "else", "{", "try", "{", "Context", ".", "waitUntil", "(", "ExpectedConditions", ".", "not", "(", "ExpectedConditions", ".", "presenceOfAllElementsLocatedBy", "(", "Utilities", ".", "getLocator", "(", "pageElement", ")", ")", ")", ")", ";", "}", "catch", "(", "final", "Exception", "e", ")", "{", "new", "Result", ".", "Failure", "<>", "(", "e", ".", "getMessage", "(", ")", ",", "Messages", ".", "getMessage", "(", "Messages", ".", "FAIL_MESSAGE_ELEMENT_STILL_VISIBLE", ")", ",", "true", ",", "pageElement", ".", "getPage", "(", ")", ".", "getCallBack", "(", ")", ")", ";", "}", "}", "}" ]

[ "Checks", "if", "an", "html", "element", "(", "PageElement", ")", "is", "displayed", "." ]

[ "public", "static", "Resource", "getResource", "(", "PageContext", "pc", ",", "PageSource", "ps", ")", "throws", "PageException", "{", "return", "ps", ".", "getResourceTranslated", "(", "pc", ")", ";", "}" ]

[ "if", "the", "pageSource", "is", "based", "on", "a", "archive", "translate", "the", "source", "to", "a", "zip", ":", "//", "Resource" ]

[ "public", "final", "void", "updateFilterMap", "(", "Map", "<", "String", ",", "Object", ">", "propFilter", ")", "{", "if", "(", "propFilter", "==", "null", ")", "propFilter", "=", "new", "HashMap", "<", "String", ",", "Object", ">", "(", ")", ";", "// Then handleUpdateFilterMap can modify the filter", "propFilter", "=", "this", ".", "handleUpdateFilterMap", "(", "propFilter", ")", ";", "// Update this object's local filter.", "this", ".", "setFilterMap", "(", "propFilter", ")", ";", "// Update any remote copy of this.", "}" ]

[ "Update", "this", "object", "s", "filter", "with", "this", "new", "map", "information", "." ]

[ "@", "Override", "public", "String", "moveAsync", "(", "String", "apiKey", ",", "String", "from", ",", "String", "to", ")", "{", "checkNotNull", "(", "from", ",", "\"from\"", ")", ";", "checkNotNull", "(", "to", ",", "\"to\"", ")", ";", "try", "{", "URI", "uri", "=", "_databus", ".", "clone", "(", ")", ".", "segment", "(", "\"_move\"", ")", ".", "queryParam", "(", "\"from\"", ",", "from", ")", ".", "queryParam", "(", "\"to\"", ",", "to", ")", ".", "build", "(", ")", ";", "Map", "<", "String", ",", "Object", ">", "response", "=", "_client", ".", "resource", "(", "uri", ")", ".", "header", "(", "ApiKeyRequest", ".", "AUTHENTICATION_HEADER", ",", "apiKey", ")", ".", "post", "(", "new", "TypeReference", "<", "Map", "<", "String", ",", "Object", ">", ">", "(", ")", "{", "}", ",", "null", ")", ";", "return", "response", ".", "get", "(", "\"id\"", ")", ".", "toString", "(", ")", ";", "}", "catch", "(", "EmoClientException", "e", ")", "{", "throw", "convertException", "(", "e", ")", ";", "}", "}" ]

[ "Any", "server", "can", "initiate", "a", "move", "request", "no", "need", "for" ]

[ "public", "static", "void", "drawRectangle", "(", "Rectangle2D_I32", "rect", ",", "Graphics2D", "g2", ")", "{", "g2", ".", "drawLine", "(", "rect", ".", "x0", ",", "rect", ".", "y0", ",", "rect", ".", "x1", ",", "rect", ".", "y0", ")", ";", "g2", ".", "drawLine", "(", "rect", ".", "x1", ",", "rect", ".", "y0", ",", "rect", ".", "x1", ",", "rect", ".", "y1", ")", ";", "g2", ".", "drawLine", "(", "rect", ".", "x0", ",", "rect", ".", "y1", ",", "rect", ".", "x1", ",", "rect", ".", "y1", ")", ";", "g2", ".", "drawLine", "(", "rect", ".", "x0", ",", "rect", ".", "y1", ",", "rect", ".", "x0", ",", "rect", ".", "y0", ")", ";", "}" ]

[ "Draws", "an", "axis", "aligned", "rectangle" ]

[ "public", "synchronized", "void", "putList", "(", "String", "bucket", ",", "@", "Nullable", "String", "objectNamePrefix", ",", "List", "<", "GoogleCloudStorageItemInfo", ">", "items", ")", "{", "// Give all entries the same creation time so they expire at the same time.", "long", "creationTime", "=", "ticker", ".", "read", "(", ")", ";", "PrefixKey", "key", "=", "new", "PrefixKey", "(", "bucket", ",", "objectNamePrefix", ")", ";", "// The list being inserted is always fresher than any child lists.", "getPrefixSubMap", "(", "itemMap", ",", "key", ")", ".", "clear", "(", ")", ";", "getPrefixSubMap", "(", "prefixMap", ",", "key", ")", ".", "clear", "(", ")", ";", "// Populate the maps.", "prefixMap", ".", "put", "(", "key", ",", "new", "CacheValue", "<", "Object", ">", "(", "null", ",", "creationTime", ")", ")", ";", "for", "(", "GoogleCloudStorageItemInfo", "item", ":", "items", ")", "{", "StorageResourceId", "itemId", "=", "item", ".", "getResourceId", "(", ")", ";", "PrefixKey", "itemKey", "=", "new", "PrefixKey", "(", "itemId", ".", "getBucketName", "(", ")", ",", "itemId", ".", "getObjectName", "(", ")", ")", ";", "CacheValue", "<", "GoogleCloudStorageItemInfo", ">", "itemValue", "=", "new", "CacheValue", "<", "GoogleCloudStorageItemInfo", ">", "(", "item", ",", "creationTime", ")", ";", "itemMap", ".", "put", "(", "itemKey", ",", "itemValue", ")", ";", "}", "}" ]

[ "Inserts", "a", "list", "entry", "and", "the", "given", "items", "into", "the", "cache", ".", "If", "a", "list", "entry", "under", "the", "same", "bucket", "/", "objectNamePrefix", "is", "present", "its", "expiration", "time", "is", "reset", ".", "If", "an", "item", "with", "the", "same", "resource", "id", "is", "present", "it", "is", "overwritten", "by", "the", "new", "item", "." ]

[ "private", "void", "fillRampDataIntoBuffers", "(", "final", "int", "[", "]", "leftBuffer", ",", "final", "int", "[", "]", "rightBuffer", ",", "final", "ChannelMemory", "aktMemo", ")", "{", "// Remember changeable values", "final", "int", "currentTuningPos", "=", "aktMemo", ".", "currentTuningPos", ";", "final", "int", "currentSamplePos", "=", "aktMemo", ".", "currentSamplePos", ";", "final", "int", "currentDirection", "=", "aktMemo", ".", "currentDirection", ";", "final", "boolean", "instrumentFinished", "=", "aktMemo", ".", "instrumentFinished", ";", "final", "int", "actRampVolLeft", "=", "aktMemo", ".", "actRampVolLeft", ";", "final", "int", "actRampVolRight", "=", "aktMemo", ".", "actRampVolRight", ";", "mixChannelIntoBuffers", "(", "leftBuffer", ",", "rightBuffer", ",", "0", ",", "Helpers", ".", "VOL_RAMP_LEN", ",", "aktMemo", ")", ";", "// set them back", "aktMemo", ".", "currentTuningPos", "=", "currentTuningPos", ";", "aktMemo", ".", "currentSamplePos", "=", "currentSamplePos", ";", "aktMemo", ".", "instrumentFinished", "=", "instrumentFinished", ";", "aktMemo", ".", "currentDirection", "=", "currentDirection", ";", "aktMemo", ".", "actRampVolLeft", "=", "actRampVolLeft", ";", "aktMemo", ".", "actRampVolRight", "=", "actRampVolRight", ";", "}" ]

[ "Retrieves", "Sample", "Data", "without", "manipulating", "the", "currentSamplePos", "and", "currentTuningPos", "and", "currentDirection", "(", "a", "kind", "of", "read", "ahead", ")" ]

[ "public", "static", "String", "getMandatoryConfig", "(", "Configuration", "config", ",", "String", "key", ")", "throws", "IOException", "{", "String", "value", "=", "config", ".", "get", "(", "key", ")", ";", "if", "(", "Strings", ".", "isNullOrEmpty", "(", "value", ")", ")", "{", "throw", "new", "IOException", "(", "\"Must supply a value for configuration setting: \"", "+", "key", ")", ";", "}", "return", "value", ";", "}" ]

[ "Gets", "value", "for", "the", "given", "key", "or", "throws", "if", "value", "is", "not", "found", "." ]

[ "@", "Controller", "public", "void", "askWhetherToRepeat", "(", "WebSocketSession", "session", ",", "Event", "event", ")", "{", "if", "(", "event", ".", "getText", "(", ")", ".", "contains", "(", "\"yes\"", ")", ")", "{", "reply", "(", "session", ",", "event", ",", "\"Great! I will remind you tomorrow before the meeting.\"", ")", ";", "}", "else", "{", "reply", "(", "session", ",", "event", ",", "\"Okay, don't forget to attend the meeting tomorrow :)\"", ")", ";", "}", "stopConversation", "(", "event", ")", ";", "// stop conversation", "}" ]

[ "This", "method", "will", "be", "invoked", "after", "{", "@link", "SlackBot#askTimeForMeeting", "(", "WebSocketSession", "Event", ")", "}", "." ]

[ "private", "String", "determineTargetURL", "(", "FacesContext", "context", ",", "Button", "button", ",", "String", "outcome", ")", "{", "ConfigurableNavigationHandler", "cnh", "=", "(", "ConfigurableNavigationHandler", ")", "context", ".", "getApplication", "(", ")", ".", "getNavigationHandler", "(", ")", ";", "NavigationCase", "navCase", "=", "cnh", ".", "getNavigationCase", "(", "context", ",", "null", ",", "outcome", ")", ";", "/*\n\t\t * Param Name: javax.faces.PROJECT_STAGE Default Value: The default\n\t\t * value is ProjectStage#Production but IDE can set it differently in\n\t\t * web.xml Expected Values: Development, Production, SystemTest,\n\t\t * UnitTest Since: 2.0\n\t\t *\n\t\t * If we cannot get an outcome we use an Alert to give a feedback to the\n\t\t * Developer if this build is in the Development Stage\n\t\t */", "if", "(", "navCase", "==", "null", ")", "{", "if", "(", "FacesContext", ".", "getCurrentInstance", "(", ")", ".", "getApplication", "(", ")", ".", "getProjectStage", "(", ")", ".", "equals", "(", "ProjectStage", ".", "Development", ")", ")", "{", "return", "\"alert('WARNING! \"", "+", "C", ".", "W_NONAVCASE_BUTTON", "+", "\"');\"", ";", "}", "else", "{", "return", "\"\"", ";", "}", "}", "// throw new FacesException(\"The outcome '\"+outcome+\"' cannot be", "// resolved.\"); }", "String", "vId", "=", "navCase", ".", "getToViewId", "(", "context", ")", ";", "Map", "<", "String", ",", "List", "<", "String", ">", ">", "params", "=", "getParams", "(", "navCase", ",", "button", ")", ";", "String", "url", ";", "url", "=", "context", ".", "getApplication", "(", ")", ".", "getViewHandler", "(", ")", ".", "getBookmarkableURL", "(", "context", ",", "vId", ",", "params", ",", "button", ".", "isIncludeViewParams", "(", ")", "||", "navCase", ".", "isIncludeViewParams", "(", ")", ")", ";", "return", "url", ";", "}" ]

[ "Translate", "the", "outcome", "attribute", "value", "to", "the", "target", "URL", "." ]

[ "public", "static", "double", "fastElementP", "(", "DMatrixD1", "A", ",", "double", "p", ")", "{", "if", "(", "p", "==", "2", ")", "{", "return", "fastNormF", "(", "A", ")", ";", "}", "else", "{", "double", "total", "=", "0", ";", "int", "size", "=", "A", ".", "getNumElements", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "size", ";", "i", "++", ")", "{", "double", "a", "=", "A", ".", "get", "(", "i", ")", ";", "total", "+=", "Math", ".", "pow", "(", "Math", ".", "abs", "(", "a", ")", ",", "p", ")", ";", "}", "return", "Math", ".", "pow", "(", "total", ",", "1.0", "/", "p", ")", ";", "}", "}" ]

[ "Same", "as", "{", "@link", "#elementP", "}", "but", "runs", "faster", "by", "not", "mitigating", "overflow", "/", "underflow", "related", "problems", "." ]

[ "protected", "ActionForward", "invokeActionMethod", "(", "Method", "method", ",", "Object", "arg", ")", "throws", "Exception", "{", "return", "invokeActionMethod", "(", "method", ",", "arg", ",", "getRequest", "(", ")", ",", "getActionMapping", "(", ")", ")", ";", "}" ]

[ "Invoke", "the", "given", "action", "handler", "method", "passing", "it", "an", "argument", "if", "appropriate", "." ]

[ "public", "static", "KeeperException", "create", "(", "Code", "code", ",", "String", "path", ")", "{", "KeeperException", "r", "=", "create", "(", "code", ")", ";", "r", ".", "path", "=", "path", ";", "return", "r", ";", "}" ]

[ "All", "non", "-", "specific", "keeper", "exceptions", "should", "be", "constructed", "via", "this", "factory", "method", "in", "order", "to", "guarantee", "consistency", "in", "error", "codes", "and", "such", ".", "If", "you", "know", "the", "error", "code", "then", "you", "should", "construct", "the", "special", "purpose", "exception", "directly", ".", "That", "will", "allow", "you", "to", "have", "the", "most", "specific", "possible", "declarations", "of", "what", "exceptions", "might", "actually", "be", "thrown", "." ]

[ "static", "double", "randomTriangular", "(", "double", "low", ",", "double", "high", ",", "double", "mode", ")", "{", "double", "u", "=", "MathUtils", ".", "random", ".", "nextDouble", "(", ")", ";", "double", "d", "=", "high", "-", "low", ";", "if", "(", "u", "<=", "(", "mode", "-", "low", ")", "/", "d", ")", "return", "low", "+", "Math", ".", "sqrt", "(", "u", "*", "d", "*", "(", "mode", "-", "low", ")", ")", ";", "return", "high", "-", "Math", ".", "sqrt", "(", "(", "1", "-", "u", ")", "*", "d", "*", "(", "high", "-", "mode", ")", ")", ";", "}" ]

[ "Returns", "a", "triangularly", "distributed", "random", "number", "between", "{" ]

[ "@", "PublicEvolving", "public", "<", "OUT", ">", "DataStreamSource", "<", "OUT", ">", "readFile", "(", "FileInputFormat", "<", "OUT", ">", "inputFormat", ",", "String", "filePath", ",", "FileProcessingMode", "watchType", ",", "long", "interval", ",", "TypeInformation", "<", "OUT", ">", "typeInformation", ")", "{", "Preconditions", ".", "checkNotNull", "(", "inputFormat", ",", "\"InputFormat must not be null.\"", ")", ";", "Preconditions", ".", "checkArgument", "(", "!", "StringUtils", ".", "isNullOrWhitespaceOnly", "(", "filePath", ")", ",", "\"The file path must not be null or blank.\"", ")", ";", "inputFormat", ".", "setFilePath", "(", "filePath", ")", ";", "return", "createFileInput", "(", "inputFormat", ",", "typeInformation", ",", "\"Custom File Source\"", ",", "watchType", ",", "interval", ")", ";", "}" ]

[ "Reads", "the", "contents", "of", "the", "user", "-", "specified", "{", "@code", "filePath", "}", "based", "on", "the", "given", "{", "@link", "FileInputFormat", "}", ".", "Depending", "on", "the", "provided", "{", "@link", "FileProcessingMode", "}", "the", "source", "may", "periodically", "monitor", "(", "every", "{", "@code", "interval", "}", "ms", ")", "the", "path", "for", "new", "data", "(", "{", "@link", "FileProcessingMode#PROCESS_CONTINUOUSLY", "}", ")", "or", "process", "once", "the", "data", "currently", "in", "the", "path", "and", "exit", "(", "{", "@link", "FileProcessingMode#PROCESS_ONCE", "}", ")", ".", "In", "addition", "if", "the", "path", "contains", "files", "not", "to", "be", "processed", "the", "user", "can", "specify", "a", "custom", "{", "@link", "FilePathFilter", "}", ".", "As", "a", "default", "implementation", "you", "can", "use", "{", "@link", "FilePathFilter#createDefaultFilter", "()", "}", "." ]

[ "private", "int", "writeAtMost", "(", "ByteBuffer", "data", ",", "int", "offset", ",", "int", "length", ")", "{", "if", "(", "current", ">=", "bufferOffset", "+", "buffer", ".", "length", ")", "reBuffer", "(", ")", ";", "assert", "current", "<", "bufferOffset", "+", "buffer", ".", "length", ":", "String", ".", "format", "(", "\"File (%s) offset %d, buffer offset %d.\"", ",", "getPath", "(", ")", ",", "current", ",", "bufferOffset", ")", ";", "int", "toCopy", "=", "Math", ".", "min", "(", "length", ",", "buffer", ".", "length", "-", "bufferCursor", "(", ")", ")", ";", "// copy bytes from external buffer", "ByteBufferUtil", ".", "arrayCopy", "(", "data", ",", "offset", ",", "buffer", ",", "bufferCursor", "(", ")", ",", "toCopy", ")", ";", "assert", "current", "<=", "bufferOffset", "+", "buffer", ".", "length", ":", "String", ".", "format", "(", "\"File (%s) offset %d, buffer offset %d.\"", ",", "getPath", "(", ")", ",", "current", ",", "bufferOffset", ")", ";", "validBufferBytes", "=", "Math", ".", "max", "(", "validBufferBytes", ",", "bufferCursor", "(", ")", "+", "toCopy", ")", ";", "current", "+=", "toCopy", ";", "return", "toCopy", ";", "}" ]

[ "/", "*", "Write", "at", "most", "length", "bytes", "from", "data", "starting", "at", "position", "offset", "and", "return", "the", "number", "of", "bytes", "written", ".", "caller", "is", "responsible", "for", "setting", "isDirty", "." ]

[ "public", "HashMap", "addEvent", "(", "String", "date", ",", "boolean", "useTemp", ")", "{", "HashMap", "ret", "=", "new", "HashMap", "(", ")", ";", "if", "(", "useTemp", ")", "{", "ret", ".", "putAll", "(", "template", ")", ";", "}", "else", "{", "ret", ".", "put", "(", "\"event\"", ",", "eventType", ")", ";", "}", "ret", ".", "put", "(", "\"date\"", ",", "date", ")", ";", "getInertIndex", "(", "ret", ")", ";", "events", ".", "add", "(", "next", ",", "ret", ")", ";", "return", "ret", ";", "}" ]

[ "Add", "a", "new", "event", "into", "array", "with", "selected", "event", "type", "and", "input", "date", "." ]

[ "public", "void", "restoreResourceVersion", "(", "CmsUUID", "structureId", ",", "int", "version", ")", "throws", "CmsException", "{", "CmsResource", "resource", "=", "readResource", "(", "structureId", ",", "CmsResourceFilter", ".", "IGNORE_EXPIRATION", ")", ";", "getResourceType", "(", "resource", ")", ".", "restoreResource", "(", "this", ",", "m_securityManager", ",", "resource", ",", "version", ")", ";", "}" ]

[ "Restores", "a", "resource", "in", "the", "current", "project", "with", "a", "version", "from", "the", "historical", "archive", ".", "<p", ">" ]

[ "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "@", "Override", "public", "double", "getDelta", "(", "DATA", "oldDataPoint", ",", "DATA", "newDataPoint", ")", "{", "if", "(", "converter", "==", "null", ")", "{", "// In case no conversion/extraction is required, we can cast DATA to", "// TO", "// => Therefore, \"unchecked\" warning is suppressed for this method.", "return", "getNestedDelta", "(", "(", "TO", ")", "oldDataPoint", ",", "(", "TO", ")", "newDataPoint", ")", ";", "}", "else", "{", "return", "getNestedDelta", "(", "converter", ".", "extract", "(", "oldDataPoint", ")", ",", "converter", ".", "extract", "(", "newDataPoint", ")", ")", ";", "}", "}" ]

[ "This", "method", "takes", "the", "two", "data", "point", "and", "runs", "the", "set", "extractor", "on", "it", ".", "The", "delta", "function", "implemented", "at", "{", "@link", "#getNestedDelta", "}", "is", "then", "called", "with", "the", "extracted", "data", ".", "In", "case", "no", "extractor", "is", "set", "the", "input", "data", "gets", "passes", "to", "{", "@link", "#getNestedDelta", "}", "as", "-", "is", ".", "The", "return", "value", "is", "just", "forwarded", "from", "{", "@link", "#getNestedDelta", "}", "." ]

[ "public", "static", "void", "writeCSVColumns", "(", "XYChart", "chart", ",", "String", "path2Dir", ")", "{", "for", "(", "XYSeries", "xySeries", ":", "chart", ".", "getSeriesMap", "(", ")", ".", "values", "(", ")", ")", "{", "writeCSVColumns", "(", "xySeries", ",", "path2Dir", ")", ";", "}", "}" ]

[ "Export", "all", "XYChart", "series", "as", "columns", "in", "separate", "CSV", "files", "." ]

[ "private", "static", "int", "computeChecksum", "(", "byte", "[", "]", "buf", ",", "int", "offset", ",", "int", "length", ",", "String", "channel", ")", "{", "Hasher", "hasher", "=", "Hashing", ".", "murmur3_32", "(", ")", ".", "newHasher", "(", ")", ";", "hasher", ".", "putBytes", "(", "buf", ",", "offset", ",", "length", ")", ";", "hasher", ".", "putUnencodedChars", "(", "channel", ")", ";", "return", "hasher", ".", "hash", "(", ")", ".", "asInt", "(", ")", "&", "0xffff", ";", "}" ]

[ "Computes", "a", "16", "-", "bit", "checksum", "of", "the", "contents", "of", "the", "specific", "ByteBuffer", "and", "channel", "name", "." ]

[ "protected", "void", "synchronizeField", "(", "Map", "<", "String", ",", "String", ">", "settings", ",", "QueryPage", "queryPage", ",", "QueryOption", "optionsOption", ",", "String", "fieldName", ",", "String", "fieldCaption", ",", "Boolean", "mandatory", ")", "{", "List", "<", "String", ">", "options", "=", "QueryPageUtils", ".", "parseSerializedList", "(", "settings", ".", "get", "(", "optionsOption", ".", "getName", "(", ")", ")", ")", ";", "synchronizeField", "(", "queryPage", ",", "options", ",", "fieldName", ",", "fieldCaption", ",", "mandatory", ")", ";", "}" ]

[ "Synchronizes", "field", "meta", ".", "Should", "not", "be", "used", "when", "field", "already", "contains", "replies" ]

[ "public", "void", "setComments", "(", "String", "tag", ",", "List", "<", "String", ">", "comments", ")", "{", "String", "nt", "=", "normaliseTag", "(", "tag", ")", ";", "if", "(", "this", ".", "comments", ".", "containsKey", "(", "nt", ")", ")", "{", "this", ".", "comments", ".", "remove", "(", "nt", ")", ";", "}", "this", ".", "comments", ".", "put", "(", "nt", ",", "comments", ")", ";", "}" ]

[ "Removes", "any", "existing", "comments", "for", "a", "given", "tag", "and", "replaces", "them", "with", "the", "supplied", "list" ]

[ "public", "void", "setUpdateIssues", "(", "String", "updateIssues", ",", "boolean", "addOnIssues", ")", "{", "Validate", ".", "notNull", "(", "updateIssues", ",", "\"Parameter updateIssues must not be null.\"", ")", ";", "this", ".", "updateIssues", "=", "updateIssues", ";", "this", ".", "addOnUpdateIssues", "=", "addOnIssues", ";", "}" ]

[ "Sets", "the", "issues", "that", "the", "newer", "version", "of", "the", "wrapped", "add", "-", "on", "or", "its", "extensions", "might", "have", "that", "prevents", "them", "from", "being", "run", ".", "<p", ">", "The", "contents", "should", "be", "in", "HTML", "." ]

[ "protected", "void", "addCommand", "(", "String", "label", ",", "String", "help", ",", "Command", "cmd", ",", "boolean", "needsAuth", ")", "{", "commands", ".", "put", "(", "label", ".", "toUpperCase", "(", ")", ",", "new", "CommandInfo", "(", "cmd", ",", "help", ",", "needsAuth", ")", ")", ";", "}" ]

[ "Internally", "registers", "a", "command" ]