Datasets:

CM

/

codexglue_code2text_java

like 4

[ "private", "void", "paintMaximizePressed", "(", "Graphics2D", "g", ",", "JComponent", "c", ",", "int", "width", ",", "int", "height", ")", "{", "maximizePainter", ".", "paintPressed", "(", "g", ",", "c", ",", "width", ",", "height", ")", ";", "}" ]

[ "Paint", "the", "foreground", "maximize", "button", "pressed", "state", "." ]

[ "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "@", "Override", "public", "void", "paintIcon", "(", "Component", "c", ",", "Graphics", "g", ",", "int", "x", ",", "int", "y", ")", "{", "SeaGlassPainter", "painter", "=", "(", "SeaGlassPainter", ")", "UIManager", ".", "get", "(", "prefix", "+", "\"[Enabled].\"", "+", "key", ")", ";", "if", "(", "painter", "!=", "null", ")", "{", "JComponent", "jc", "=", "(", "c", "instanceof", "JComponent", ")", "?", "(", "JComponent", ")", "c", ":", "null", ";", "Graphics2D", "gfx", "=", "(", "Graphics2D", ")", "g", ";", "gfx", ".", "translate", "(", "x", ",", "y", ")", ";", "painter", ".", "paint", "(", "gfx", ",", "jc", ",", "width", ",", "height", ")", ";", "gfx", ".", "translate", "(", "-", "x", ",", "-", "y", ")", ";", "}", "}" ]

[ "Implements", "the", "standard", "Icon", "interface", "s", "paintIcon", "method", "as", "the", "standard", "synth", "stub", "passes", "null", "for", "the", "context", "and", "this", "will", "cause", "us", "to", "not", "paint", "any", "thing", "so", "we", "override", "here", "so", "that", "we", "can", "paint", "the", "enabled", "state", "if", "no", "synth", "context", "is", "available" ]

[ "private", "int", "scale", "(", "SynthContext", "context", ",", "int", "size", ")", "{", "if", "(", "context", "==", "null", "||", "context", ".", "getComponent", "(", ")", "==", "null", ")", "{", "return", "size", ";", "}", "// The key \"JComponent.sizeVariant\" is used to match Apple's LAF", "String", "scaleKey", "=", "SeaGlassStyle", ".", "getSizeVariant", "(", "context", ".", "getComponent", "(", ")", ")", ";", "if", "(", "scaleKey", "!=", "null", ")", "{", "if", "(", "SeaGlassStyle", ".", "LARGE_KEY", ".", "equals", "(", "scaleKey", ")", ")", "{", "size", "*=", "SeaGlassStyle", ".", "LARGE_SCALE", ";", "}", "else", "if", "(", "SeaGlassStyle", ".", "SMALL_KEY", ".", "equals", "(", "scaleKey", ")", ")", "{", "size", "*=", "SeaGlassStyle", ".", "SMALL_SCALE", ";", "}", "else", "if", "(", "SeaGlassStyle", ".", "MINI_KEY", ".", "equals", "(", "scaleKey", ")", ")", "{", "// mini is not quite as small for icons as full mini is", "// just too tiny", "size", "*=", "SeaGlassStyle", ".", "MINI_SCALE", "+", "0.07", ";", "}", "}", "return", "size", ";", "}" ]

[ "Scale", "a", "size", "based", "on", "the", "JComponent", ".", "sizeVariant", "client", "property", "of", "the", "component", "that", "is", "using", "this", "icon" ]

[ "public", "static", "boolean", "isConnectionClosure", "(", "ShutdownSignalException", "e", ")", "{", "return", "e", "instanceof", "AlreadyClosedException", "?", "e", ".", "getReference", "(", ")", "instanceof", "Connection", ":", "e", ".", "isHardError", "(", ")", ";", "}" ]

[ "Reliably", "returns", "whether", "the", "shutdown", "signal", "represents", "a", "connection", "closure", "." ]

[ "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "public", "T", "withMaxDuration", "(", "Duration", "maxDuration", ")", "{", "Assert", ".", "notNull", "(", "maxDuration", ",", "\"maxDuration\"", ")", ";", "this", ".", "maxDuration", "=", "maxDuration", ";", "return", "(", "T", ")", "this", ";", "}" ]

[ "Sets", "the", "max", "duration", "to", "perform", "attempts", "for", "." ]

[ "boolean", "handleCommonMethods", "(", "Object", "delegate", ",", "Method", "method", ",", "Object", "[", "]", "args", ")", "throws", "Throwable", "{", "if", "(", "\"abort\"", ".", "equals", "(", "method", ".", "getName", "(", ")", ")", "||", "\"close\"", ".", "equals", "(", "method", ".", "getName", "(", ")", ")", ")", "{", "try", "{", "Reflection", ".", "invoke", "(", "delegate", ",", "method", ",", "args", ")", ";", "return", "true", ";", "}", "finally", "{", "closed", "=", "true", ";", "afterClosure", "(", ")", ";", "interruptWaiters", "(", ")", ";", "}", "}", "else", "if", "(", "\"addShutdownListener\"", ".", "equals", "(", "method", ".", "getName", "(", ")", ")", "&&", "args", "[", "0", "]", "!=", "null", ")", "shutdownListeners", ".", "add", "(", "(", "ShutdownListener", ")", "args", "[", "0", "]", ")", ";", "else", "if", "(", "\"removeShutdownListener\"", ".", "equals", "(", "method", ".", "getName", "(", ")", ")", "&&", "args", "[", "0", "]", "!=", "null", ")", "shutdownListeners", ".", "remove", "(", "(", "ShutdownListener", ")", "args", "[", "0", "]", ")", ";", "return", "false", ";", "}" ]

[ "Handles", "common", "method", "invocations", "." ]

[ "public", "boolean", "isPolicyExceeded", "(", ")", "{", "boolean", "withinMaxRetries", "=", "maxAttempts", "==", "-", "1", "||", "attemptCount", "<", "maxAttempts", ";", "boolean", "withinMaxDuration", "=", "maxDuration", "==", "-", "1", "||", "System", ".", "nanoTime", "(", ")", "-", "startTime", "<", "maxDuration", ";", "return", "!", "withinMaxRetries", "||", "!", "withinMaxDuration", ";", "}" ]

[ "Returns", "true", "if", "the", "max", "attempts", "or", "max", "duration", "for", "the", "recurring", "policy", "have", "been", "exceeded", "else", "false", "." ]

[ "public", "Iterable", "<", "V", ">", "values", "(", ")", "{", "return", "new", "Iterable", "<", "V", ">", "(", ")", "{", "@", "Override", "public", "Iterator", "<", "V", ">", "iterator", "(", ")", "{", "return", "new", "Iterator", "<", "V", ">", "(", ")", "{", "final", "Iterator", "<", "List", "<", "V", ">", ">", "valuesIterator", "=", "map", ".", "values", "(", ")", ".", "iterator", "(", ")", ";", "Iterator", "<", "V", ">", "current", ";", "{", "if", "(", "valuesIterator", ".", "hasNext", "(", ")", ")", "current", "=", "valuesIterator", ".", "next", "(", ")", ".", "iterator", "(", ")", ";", "}", "@", "Override", "public", "boolean", "hasNext", "(", ")", "{", "return", "current", "!=", "null", "&&", "current", ".", "hasNext", "(", ")", ";", "}", "@", "Override", "public", "V", "next", "(", ")", "{", "V", "value", "=", "current", ".", "next", "(", ")", ";", "while", "(", "!", "current", ".", "hasNext", "(", ")", "&&", "valuesIterator", ".", "hasNext", "(", ")", ")", "current", "=", "valuesIterator", ".", "next", "(", ")", ".", "iterator", "(", ")", ";", "return", "value", ";", "}", "@", "Override", "public", "void", "remove", "(", ")", "{", "throw", "new", "UnsupportedOperationException", "(", ")", ";", "}", "}", ";", "}", "}", ";", "}" ]

[ "Returns", "an", "iterable", "over", "the", "multimap", "s", "values", ".", "Unsafe", "for", "concurrent", "modification", "." ]

[ "synchronized", "void", "recoverChannel", "(", "boolean", "viaConnectionRecovery", ")", "throws", "Exception", "{", "recoveryPending", ".", "set", "(", "false", ")", ";", "if", "(", "circuit", ".", "isClosed", "(", ")", ")", "return", ";", "if", "(", "recoveryStats", "==", "null", ")", "{", "recoveryConsumers", "=", "consumerDeclarations", ".", "isEmpty", "(", ")", "?", "null", ":", "new", "LinkedHashMap", "<", "String", ",", "ConsumerDeclaration", ">", "(", "consumerDeclarations", ")", ";", "recoveryStats", "=", "new", "RecurringStats", "(", "config", ".", "getChannelRecoveryPolicy", "(", ")", ")", ";", "recoveryStats", ".", "incrementTime", "(", ")", ";", "}", "else", "if", "(", "recoveryStats", ".", "isPolicyExceeded", "(", ")", ")", "{", "recoveryFailed", "(", "lastShutdownSignal", ")", ";", "if", "(", "!", "viaConnectionRecovery", ")", "return", ";", "}", "try", "{", "notifyRecoveryStarted", "(", ")", ";", "delegate", "=", "callWithRetries", "(", "new", "Callable", "<", "Channel", ">", "(", ")", "{", "@", "Override", "public", "Channel", "call", "(", ")", "throws", "Exception", "{", "log", ".", "info", "(", "\"Recovering {}\"", ",", "ChannelHandler", ".", "this", ")", ";", "previousMaxDeliveryTag", "=", "maxDeliveryTag", ";", "Channel", "channel", "=", "connectionHandler", ".", "createChannel", "(", "delegate", ".", "getChannelNumber", "(", ")", ")", ";", "migrateConfiguration", "(", "channel", ")", ";", "log", ".", "info", "(", "\"Recovered {}\"", ",", "ChannelHandler", ".", "this", ")", ";", "return", "channel", ";", "}", "}", ",", "config", ".", "getChannelRecoveryPolicy", "(", ")", ",", "recoveryStats", ",", "config", ".", "getRecoverableExceptions", "(", ")", ",", "true", ",", "false", ")", ";", "notifyRecovery", "(", ")", ";", "recoverConsumers", "(", "!", "viaConnectionRecovery", ")", ";", "recoverySucceeded", "(", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "ShutdownSignalException", "sse", "=", "Exceptions", ".", "extractCause", "(", "e", ",", "ShutdownSignalException", ".", "class", ")", ";", "if", "(", "sse", "!=", "null", ")", "{", "if", "(", "Exceptions", ".", "isConnectionClosure", "(", "sse", ")", ")", "throw", "e", ";", "}", "else", "if", "(", "recoveryStats", ".", "isPolicyExceeded", "(", ")", ")", "recoveryFailed", "(", "e", ")", ";", "}", "}" ]

[ "Atomically", "recovers", "the", "channel", "." ]

[ "private", "void", "recoverConsumers", "(", "boolean", "recoverReferences", ")", "throws", "Exception", "{", "if", "(", "config", ".", "isConsumerRecoveryEnabled", "(", ")", "&&", "!", "recoveryPending", ".", "get", "(", ")", "&&", "recoveryConsumers", "!=", "null", ")", "{", "Set", "<", "QueueDeclaration", ">", "recoveredQueues", "=", "new", "HashSet", "<", "QueueDeclaration", ">", "(", ")", ";", "Set", "<", "String", ">", "recoveredExchanges", "=", "new", "HashSet", "<", "String", ">", "(", ")", ";", "for", "(", "Iterator", "<", "Map", ".", "Entry", "<", "String", ",", "ConsumerDeclaration", ">", ">", "it", "=", "recoveryConsumers", ".", "entrySet", "(", ")", ".", "iterator", "(", ")", ";", "it", ".", "hasNext", "(", ")", ";", ")", "{", "Map", ".", "Entry", "<", "String", ",", "ConsumerDeclaration", ">", "entry", "=", "it", ".", "next", "(", ")", ";", "ConsumerDeclaration", "consumerDeclaration", "=", "entry", ".", "getValue", "(", ")", ";", "Object", "[", "]", "args", "=", "consumerDeclaration", ".", "args", ";", "ConsumerDelegate", "consumer", "=", "(", "ConsumerDelegate", ")", "args", "[", "args", ".", "length", "-", "1", "]", ";", "String", "queueName", "=", "consumerDeclaration", ".", "queueDeclaration", "!=", "null", "?", "consumerDeclaration", ".", "queueDeclaration", ".", "name", ":", "(", "String", ")", "args", "[", "0", "]", ";", "try", "{", "// Recover referenced exchanges, queues and bindings", "if", "(", "recoverReferences", ")", "{", "List", "<", "Binding", ">", "queueBindings", "=", "connectionHandler", ".", "queueBindings", ".", "get", "(", "queueName", ")", ";", "recoverRelatedExchanges", "(", "recoveredExchanges", ",", "queueBindings", ")", ";", "if", "(", "consumerDeclaration", ".", "queueDeclaration", "!=", "null", "&&", "recoveredQueues", ".", "add", "(", "consumerDeclaration", ".", "queueDeclaration", ")", ")", "queueName", "=", "recoverQueue", "(", "queueName", ",", "consumerDeclaration", ".", "queueDeclaration", ",", "queueBindings", ")", ";", "}", "// Recover consumer", "log", ".", "info", "(", "\"\"", ".", "equals", "(", "queueName", ")", "?", "\"Recovering consumer-{}{} via {}\"", ":", "\"Recovering consumer-{} of {} via {}\"", ",", "entry", ".", "getKey", "(", ")", ",", "queueName", ",", "this", ")", ";", "notifyConsumerRecoveryStarted", "(", "consumer", ")", ";", "consumer", ".", "open", "(", ")", ";", "consumerDeclaration", ".", "invoke", "(", "delegate", ")", ";", "log", ".", "info", "(", "\"\"", ".", "equals", "(", "queueName", ")", "?", "\"Recovered consumer-{}{} via {}\"", ":", "\"Recovered consumer-{} of {} via {}\"", ",", "entry", ".", "getKey", "(", ")", ",", "queueName", ",", "this", ")", ";", "notifyConsumerRecoveryCompleted", "(", "consumer", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "log", ".", "error", "(", "\"Failed to recover consumer-{} via {}\"", ",", "entry", ".", "getKey", "(", ")", ",", "this", ",", "e", ")", ";", "notifyConsumerRecoveryFailure", "(", "consumer", ",", "e", ")", ";", "ShutdownSignalException", "sse", "=", "Exceptions", ".", "extractCause", "(", "e", ",", "ShutdownSignalException", ".", "class", ")", ";", "if", "(", "sse", "!=", "null", ")", "{", "if", "(", "!", "Exceptions", ".", "isConnectionClosure", "(", "sse", ")", ")", "it", ".", "remove", "(", ")", ";", "throw", "e", ";", "}", "}", "}", "}", "}" ]

[ "Recovers", "the", "channel", "s", "consumers", "along", "with", "any", "exchanges", "exchange", "bindings", "queues", "and", "queue", "bindings", "that", "are", "referenced", "by", "the", "consumer", ".", "If", "a", "consumer", "recovery", "fails", "due", "to", "a", "channel", "closure", "then", "we", "will", "not", "attempt", "to", "recover", "that", "consumer", "or", "its", "references", "again", "." ]

[ "public", "Address", "[", "]", "getAddresses", "(", ")", "{", "if", "(", "addresses", "!=", "null", ")", "return", "addresses", ";", "if", "(", "hosts", "!=", "null", ")", "{", "addresses", "=", "new", "Address", "[", "hosts", ".", "length", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "hosts", ".", "length", ";", "i", "++", ")", "addresses", "[", "i", "]", "=", "new", "Address", "(", "hosts", "[", "i", "]", ",", "factory", ".", "getPort", "(", ")", ")", ";", "return", "addresses", ";", "}", "Address", "address", "=", "factory", "==", "null", "?", "new", "Address", "(", "\"localhost\"", ",", "-", "1", ")", ":", "new", "Address", "(", "factory", ".", "getHost", "(", ")", ",", "factory", ".", "getPort", "(", ")", ")", ";", "return", "new", "Address", "[", "]", "{", "address", "}", ";", "}" ]

[ "Returns", "the", "addresses", "to", "attempt", "connections", "to", "in", "round", "-", "robin", "order", "." ]

[ "public", "ConnectionOptions", "withClientProperties", "(", "Map", "<", "String", ",", "Object", ">", "clientProperties", ")", "{", "factory", ".", "setClientProperties", "(", "Assert", ".", "notNull", "(", "clientProperties", ",", "\"clientProperties\"", ")", ")", ";", "return", "this", ";", "}" ]

[ "Sets", "the", "client", "properties", "." ]

[ "public", "ConnectionOptions", "withNioParams", "(", "NioParams", "nioParams", ")", "{", "this", ".", "nioParams", "=", "nioParams", ";", "factory", ".", "setNioParams", "(", "Assert", ".", "notNull", "(", "nioParams", ",", "\"nioParams\"", ")", ")", ";", "factory", ".", "useNio", "(", ")", ";", "return", "this", ";", "}" ]

[ "Support", "for", "Java", "non", "-", "blocking", "IO" ]

[ "public", "Match", "include", "(", "String", "...", "fields", ")", "{", "if", "(", "fields", "!=", "null", ")", "{", "includes", ".", "addAll", "(", "Arrays", ".", "asList", "(", "fields", ")", ")", ";", "}", "return", "this", ";", "}" ]

[ "Mark", "fields", "for", "inclusion", "during", "serialization", "." ]

[ "public", "Match", "exclude", "(", "String", "...", "fields", ")", "{", "if", "(", "fields", "!=", "null", ")", "{", "excludes", ".", "addAll", "(", "Arrays", ".", "asList", "(", "fields", ")", ")", ";", "}", "return", "this", ";", "}" ]

[ "Mark", "fields", "for", "exclusion", "during", "serialization", "." ]

[ "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "public", "<", "X", ",", "Y", ",", "Z", ">", "Match", "transform", "(", "String", "field", ",", "BiFunction", "<", "X", ",", "Y", ",", "Z", ">", "transformer", ")", "{", "transforms", ".", "put", "(", "field", ",", "(", "BiFunction", "<", "Object", ",", "Object", ",", "Object", ">", ")", "transformer", ")", ";", "return", "this", ";", "}" ]

[ "Mark", "a", "field", "for", "transformation", "during", "serialization", "." ]

[ "public", "boolean", "dispatchTouchEvent", "(", "final", "MotionEvent", "event", ")", "{", "checkNotNull", "(", "event", ",", "\"event == null\"", ")", ";", "boolean", "isEventConsumed", "=", "false", ";", "switch", "(", "event", ".", "getAction", "(", ")", ")", "{", "case", "MotionEvent", ".", "ACTION_DOWN", ":", "// user started touching the screen", "onActionDown", "(", "event", ")", ";", "break", ";", "case", "MotionEvent", ".", "ACTION_UP", ":", "// user stopped touching the screen", "isEventConsumed", "=", "onActionUp", "(", "event", ")", ";", "break", ";", "case", "MotionEvent", ".", "ACTION_MOVE", ":", "// user is moving finger on the screen", "onActionMove", "(", "event", ")", ";", "break", ";", "default", ":", "break", ";", "}", "return", "isEventConsumed", ";", "}" ]

[ "Called", "to", "process", "touch", "screen", "events", "." ]

[ "public", "boolean", "check", "(", ")", "throws", "IOException", ",", "TrustyUriException", "{", "TrustyUriModule", "module", "=", "ModuleDirectory", ".", "getModule", "(", "r", ".", "getModuleId", "(", ")", ")", ";", "if", "(", "module", "==", "null", ")", "{", "throw", "new", "TrustyUriException", "(", "\"ERROR: Not a trusty URI or unknown module\"", ")", ";", "}", "return", "module", ".", "hasCorrectHash", "(", "r", ")", ";", "}" ]

[ "Checks", "whether", "the", "content", "matches", "the", "hash", "of", "the", "trusty", "URI", "." ]

[ "private", "void", "init", "(", "Context", "context", ",", "AttributeSet", "attrs", ",", "int", "defStyleAttr", ")", "{", "TypedArray", "a", "=", "context", ".", "obtainStyledAttributes", "(", "attrs", ",", "R", ".", "styleable", ".", "CircularSlider", ",", "defStyleAttr", ",", "0", ")", ";", "// read all available attributes", "float", "startAngle", "=", "a", ".", "getFloat", "(", "R", ".", "styleable", ".", "CircularSlider_start_angle", ",", "(", "float", ")", "Math", ".", "PI", "/", "2", ")", ";", "float", "angle", "=", "a", ".", "getFloat", "(", "R", ".", "styleable", ".", "CircularSlider_angle", ",", "(", "float", ")", "Math", ".", "PI", "/", "2", ")", ";", "int", "thumbSize", "=", "a", ".", "getDimensionPixelSize", "(", "R", ".", "styleable", ".", "CircularSlider_thumb_size", ",", "50", ")", ";", "int", "thumbColor", "=", "a", ".", "getColor", "(", "R", ".", "styleable", ".", "CircularSlider_thumb_color", ",", "Color", ".", "GRAY", ")", ";", "int", "borderThickness", "=", "a", ".", "getDimensionPixelSize", "(", "R", ".", "styleable", ".", "CircularSlider_border_thickness", ",", "20", ")", ";", "int", "borderColor", "=", "a", ".", "getColor", "(", "R", ".", "styleable", ".", "CircularSlider_border_color", ",", "Color", ".", "RED", ")", ";", "String", "borderGradientColors", "=", "a", ".", "getString", "(", "R", ".", "styleable", ".", "CircularSlider_border_gradient_colors", ")", ";", "Drawable", "thumbImage", "=", "a", ".", "getDrawable", "(", "R", ".", "styleable", ".", "CircularSlider_thumb_image", ")", ";", "// save those to fields (really, do we need setters here..?)", "setStartAngle", "(", "startAngle", ")", ";", "setAngle", "(", "angle", ")", ";", "setBorderThickness", "(", "borderThickness", ")", ";", "setBorderColor", "(", "borderColor", ")", ";", "if", "(", "borderGradientColors", "!=", "null", ")", "{", "setBorderGradientColors", "(", "borderGradientColors", ".", "split", "(", "\";\"", ")", ")", ";", "}", "setThumbSize", "(", "thumbSize", ")", ";", "setThumbImage", "(", "thumbImage", ")", ";", "setThumbColor", "(", "thumbColor", ")", ";", "// assign padding - check for version because of RTL layout compatibility", "int", "padding", ";", "if", "(", "Build", ".", "VERSION", ".", "SDK_INT", ">=", "Build", ".", "VERSION_CODES", ".", "JELLY_BEAN_MR1", ")", "{", "int", "all", "=", "getPaddingLeft", "(", ")", "+", "getPaddingRight", "(", ")", "+", "getPaddingBottom", "(", ")", "+", "getPaddingTop", "(", ")", "+", "getPaddingEnd", "(", ")", "+", "getPaddingStart", "(", ")", ";", "padding", "=", "all", "/", "6", ";", "}", "else", "{", "padding", "=", "(", "getPaddingLeft", "(", ")", "+", "getPaddingRight", "(", ")", "+", "getPaddingBottom", "(", ")", "+", "getPaddingTop", "(", ")", ")", "/", "4", ";", "}", "setPadding", "(", "padding", ")", ";", "a", ".", "recycle", "(", ")", ";", "}" ]

[ "common", "initializer", "method" ]

[ "private", "void", "updateSliderState", "(", "int", "touchX", ",", "int", "touchY", ")", "{", "int", "distanceX", "=", "touchX", "-", "mCircleCenterX", ";", "int", "distanceY", "=", "mCircleCenterY", "-", "touchY", ";", "//noinspection SuspiciousNameCombination", "double", "c", "=", "Math", ".", "sqrt", "(", "Math", ".", "pow", "(", "distanceX", ",", "2", ")", "+", "Math", ".", "pow", "(", "distanceY", ",", "2", ")", ")", ";", "mAngle", "=", "Math", ".", "acos", "(", "distanceX", "/", "c", ")", ";", "if", "(", "distanceY", "<", "0", ")", "{", "mAngle", "=", "-", "mAngle", ";", "}", "if", "(", "mListener", "!=", "null", ")", "{", "// notify slider moved listener of the new position which should be in [0..1] range", "mListener", ".", "onSliderMoved", "(", "(", "mAngle", "-", "mStartAngle", ")", "/", "(", "2", "*", "Math", ".", "PI", ")", ")", ";", "}", "}" ]

[ "Invoked", "when", "slider", "starts", "moving", "or", "is", "currently", "moving", ".", "This", "method", "calculates", "and", "sets", "position", "and", "angle", "of", "the", "thumb", "." ]

[ "private", "MetaMethod", "specialCasedOverrideForCreate", "(", "final", "Method", "m", ")", "{", "return", "new", "MetaMethod", "(", ")", "{", "@", "Override", "public", "int", "getModifiers", "(", ")", "{", "return", "m", ".", "getModifiers", "(", ")", ";", "}", "@", "Override", "public", "String", "getName", "(", ")", "{", "return", "m", ".", "getName", "(", ")", ";", "}", "@", "Override", "public", "Class", "<", "?", ">", "getReturnType", "(", ")", "{", "return", "m", ".", "getReturnType", "(", ")", ";", "}", "@", "Override", "public", "CachedClass", "getDeclaringClass", "(", ")", "{", "return", "ReflectionCache", ".", "getCachedClass", "(", "m", ".", "getDeclaringClass", "(", ")", ")", ";", "}", "@", "Override", "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "public", "Object", "invoke", "(", "Object", "object", ",", "final", "Object", "[", "]", "arguments", ")", "{", "return", "Observable", ".", "create", "(", "new", "GroovyCreateWrapper", "(", "(", "Closure", ")", "arguments", "[", "0", "]", ")", ")", ";", "}", "@", "Override", "public", "CachedClass", "[", "]", "getParameterTypes", "(", ")", "{", "if", "(", "parameterTypes", "==", "null", ")", "{", "getParametersTypes0", "(", ")", ";", "}", "return", "parameterTypes", ";", "}", "private", "synchronized", "void", "getParametersTypes0", "(", ")", "{", "if", "(", "parameterTypes", "!=", "null", ")", "return", ";", "Class", "[", "]", "npt", "=", "nativeParamTypes", "==", "null", "?", "getPT", "(", ")", ":", "nativeParamTypes", ";", "CachedClass", "[", "]", "pt", "=", "new", "CachedClass", "[", "npt", ".", "length", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "!=", "npt", ".", "length", ";", "++", "i", ")", "{", "if", "(", "Function", ".", "class", ".", "isAssignableFrom", "(", "npt", "[", "i", "]", ")", ")", "{", "// function type to be replaced by closure", "pt", "[", "i", "]", "=", "ReflectionCache", ".", "getCachedClass", "(", "Closure", ".", "class", ")", ";", "}", "else", "{", "// non-function type", "pt", "[", "i", "]", "=", "ReflectionCache", ".", "getCachedClass", "(", "npt", "[", "i", "]", ")", ";", "}", "}", "nativeParamTypes", "=", "npt", ";", "setParametersTypes", "(", "pt", ")", ";", "}", "@", "Override", "protected", "Class", "[", "]", "getPT", "(", ")", "{", "return", "m", ".", "getParameterTypes", "(", ")", ";", "}", "}", ";", "}" ]

[ "Special", "case", "until", "we", "finish", "migrating", "off", "the", "deprecated", "create", "method", "signature" ]

[ "static", "String", "rewriteIPv4MappedNotation", "(", "String", "string", ")", "{", "if", "(", "!", "string", ".", "contains", "(", "\".\"", ")", ")", "{", "return", "string", ";", "}", "else", "{", "int", "lastColon", "=", "string", ".", "lastIndexOf", "(", "\":\"", ")", ";", "String", "firstPart", "=", "string", ".", "substring", "(", "0", ",", "lastColon", "+", "1", ")", ";", "String", "mappedIPv4Part", "=", "string", ".", "substring", "(", "lastColon", "+", "1", ")", ";", "if", "(", "mappedIPv4Part", ".", "contains", "(", "\".\"", ")", ")", "{", "String", "[", "]", "dotSplits", "=", "DOT_DELIM", ".", "split", "(", "mappedIPv4Part", ")", ";", "if", "(", "dotSplits", ".", "length", "!=", "4", ")", "throw", "new", "IllegalArgumentException", "(", "String", ".", "format", "(", "\"can not parse [%s]\"", ",", "string", ")", ")", ";", "StringBuilder", "rewrittenString", "=", "new", "StringBuilder", "(", ")", ";", "rewrittenString", ".", "append", "(", "firstPart", ")", ";", "int", "byteZero", "=", "Integer", ".", "parseInt", "(", "dotSplits", "[", "0", "]", ")", ";", "int", "byteOne", "=", "Integer", ".", "parseInt", "(", "dotSplits", "[", "1", "]", ")", ";", "int", "byteTwo", "=", "Integer", ".", "parseInt", "(", "dotSplits", "[", "2", "]", ")", ";", "int", "byteThree", "=", "Integer", ".", "parseInt", "(", "dotSplits", "[", "3", "]", ")", ";", "rewrittenString", ".", "append", "(", "String", ".", "format", "(", "\"%02x\"", ",", "byteZero", ")", ")", ";", "rewrittenString", ".", "append", "(", "String", ".", "format", "(", "\"%02x\"", ",", "byteOne", ")", ")", ";", "rewrittenString", ".", "append", "(", "\":\"", ")", ";", "rewrittenString", ".", "append", "(", "String", ".", "format", "(", "\"%02x\"", ",", "byteTwo", ")", ")", ";", "rewrittenString", ".", "append", "(", "String", ".", "format", "(", "\"%02x\"", ",", "byteThree", ")", ")", ";", "return", "rewrittenString", ".", "toString", "(", ")", ";", "}", "else", "{", "throw", "new", "IllegalArgumentException", "(", "String", ".", "format", "(", "\"can not parse [%s]\"", ",", "string", ")", ")", ";", "}", "}", "}" ]

[ "Replaces", "a", "w", ".", "x", ".", "y", ".", "z", "substring", "at", "the", "end", "of", "the", "given", "string", "with", "corresponding", "hexadecimal", "notation", ".", "This", "is", "useful", "in", "case", "the", "string", "was", "using", "IPv4", "-", "Mapped", "address", "notation", "." ]

[ "public", "KeePassFileBuilder", "addTopGroups", "(", "Group", "...", "groups", ")", "{", "for", "(", "Group", "group", ":", "groups", ")", "{", "rootBuilder", ".", "addGroup", "(", "group", ")", ";", "}", "return", "this", ";", "}" ]

[ "Adds", "the", "given", "groups", "right", "under", "the", "root", "node", "." ]

[ "public", "KeePassFileBuilder", "addTopEntries", "(", "Entry", "...", "entries", ")", "{", "for", "(", "Entry", "entry", ":", "entries", ")", "{", "topGroupBuilder", ".", "addEntry", "(", "entry", ")", ";", "}", "return", "this", ";", "}" ]

[ "Add", "the", "given", "entries", "right", "under", "the", "root", "node", "." ]

[ "@", "SuppressWarnings", "(", "\"resource\"", ")", "public", "void", "read", "(", "byte", "[", "]", "keepassFile", ")", "throws", "IOException", "{", "SafeInputStream", "inputStream", "=", "new", "SafeInputStream", "(", "new", "BufferedInputStream", "(", "new", "ByteArrayInputStream", "(", "keepassFile", ")", ")", ")", ";", "inputStream", ".", "skipSafe", "(", "VERSION_SIGNATURE_LENGTH", ")", ";", "// skip version\r", "if", "(", "fileFormatVersion", "==", "0", ")", "{", "throw", "new", "UnsupportedOperationException", "(", "\"File format version not set! Make sure to call checkVersionSupport before \"", ")", ";", "}", "while", "(", "true", ")", "{", "try", "{", "int", "fieldId", "=", "inputStream", ".", "read", "(", ")", ";", "byte", "[", "]", "fieldLength", ";", "if", "(", "fileFormatVersion", "<", "DATABASE_V4_FILE_VERSION_INT", ")", "{", "fieldLength", "=", "new", "byte", "[", "2", "]", ";", "}", "else", "{", "fieldLength", "=", "new", "byte", "[", "4", "]", ";", "}", "inputStream", ".", "readSafe", "(", "fieldLength", ")", ";", "ByteBuffer", "fieldLengthBuffer", "=", "ByteBuffer", ".", "wrap", "(", "fieldLength", ")", ";", "fieldLengthBuffer", ".", "order", "(", "ByteOrder", ".", "LITTLE_ENDIAN", ")", ";", "int", "fieldLengthInt", "=", "ByteUtils", ".", "toUnsignedInt", "(", "fieldLengthBuffer", ".", "getShort", "(", ")", ")", ";", "if", "(", "fieldLengthInt", ">", "0", ")", "{", "byte", "[", "]", "data", "=", "new", "byte", "[", "fieldLengthInt", "]", ";", "inputStream", ".", "readSafe", "(", "data", ")", ";", "setValue", "(", "fieldId", ",", "data", ")", ";", "}", "if", "(", "fieldId", "==", "0", ")", "{", "break", ";", "}", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "new", "KeePassHeaderUnreadableException", "(", "\"Could not read header input\"", ",", "e", ")", ";", "}", "}", "}" ]

[ "Initializes", "the", "header", "values", "from", "a", "given", "byte", "array", "." ]

[ "public", "byte", "[", "]", "getBytes", "(", ")", "{", "try", "{", "ByteArrayOutputStream", "stream", "=", "new", "ByteArrayOutputStream", "(", ")", ";", "stream", ".", "write", "(", "DATABASE_V2_FILE_SIGNATURE_1", ")", ";", "stream", ".", "write", "(", "DATABASE_V2_FILE_SIGNATURE_2", ")", ";", "stream", ".", "write", "(", "DATABASE_V2_FILE_VERSION", ")", ";", "for", "(", "int", "i", "=", "2", ";", "i", "<", "11", ";", "i", "++", ")", "{", "byte", "[", "]", "headerValue", "=", "getValue", "(", "i", ")", ";", "// Write index\r", "stream", ".", "write", "(", "i", ")", ";", "// Write length\r", "byte", "[", "]", "length", "=", "new", "byte", "[", "]", "{", "(", "byte", ")", "headerValue", ".", "length", ",", "0", "}", ";", "stream", ".", "write", "(", "length", ")", ";", "// Write value\r", "stream", ".", "write", "(", "headerValue", ")", ";", "}", "// Write terminating flag\r", "stream", ".", "write", "(", "getEndOfHeader", "(", ")", ")", ";", "return", "stream", ".", "toByteArray", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "new", "KeePassHeaderUnreadableException", "(", "\"Could not write header value to stream\"", ",", "e", ")", ";", "}", "}" ]

[ "Returns", "the", "whole", "header", "as", "byte", "array", "." ]

[ "public", "Iterator", "<", "IPv6Network", ">", "split", "(", "IPv6NetworkMask", "size", ")", "{", "if", "(", "size", ".", "asPrefixLength", "(", ")", "<", "this", ".", "getNetmask", "(", ")", ".", "asPrefixLength", "(", ")", ")", "throw", "new", "IllegalArgumentException", "(", "String", ".", "format", "(", "\"Can not split a network of size %s in subnets of larger size %s\"", ",", "this", ".", "getNetmask", "(", ")", ".", "asPrefixLength", "(", ")", ",", "size", ".", "asPrefixLength", "(", ")", ")", ")", ";", "return", "new", "IPv6NetworkSplitsIterator", "(", "size", ")", ";", "}" ]

[ "Split", "a", "network", "in", "smaller", "subnets", "of", "a", "given", "size", "." ]

[ "public", "static", "IPv6Address", "fromInetAddress", "(", "final", "InetAddress", "inetAddress", ")", "{", "if", "(", "inetAddress", "==", "null", ")", "throw", "new", "IllegalArgumentException", "(", "\"can not construct from [null]\"", ")", ";", "return", "fromByteArray", "(", "inetAddress", ".", "getAddress", "(", ")", ")", ";", "}" ]

[ "Create", "an", "IPv6", "address", "from", "a", "java", ".", "net", ".", "Inet6Address", "." ]

[ "public", "static", "IPv6Address", "fromByteArray", "(", "final", "byte", "[", "]", "bytes", ")", "{", "if", "(", "bytes", "==", "null", ")", "throw", "new", "IllegalArgumentException", "(", "\"can not construct from [null]\"", ")", ";", "if", "(", "bytes", ".", "length", "!=", "N_BYTES", ")", "throw", "new", "IllegalArgumentException", "(", "\"the byte array to construct from should be 16 bytes long\"", ")", ";", "ByteBuffer", "buf", "=", "ByteBuffer", ".", "allocate", "(", "N_BYTES", ")", ";", "for", "(", "byte", "b", ":", "bytes", ")", "{", "buf", ".", "put", "(", "b", ")", ";", "}", "buf", ".", "rewind", "(", ")", ";", "LongBuffer", "longBuffer", "=", "buf", ".", "asLongBuffer", "(", ")", ";", "return", "new", "IPv6Address", "(", "longBuffer", ".", "get", "(", ")", ",", "longBuffer", ".", "get", "(", ")", ")", ";", "}" ]

[ "Create", "an", "IPv6", "address", "from", "a", "byte", "array", "." ]

[ "public", "IPv6Address", "add", "(", "int", "value", ")", "{", "final", "long", "newLowBits", "=", "lowBits", "+", "value", ";", "if", "(", "value", ">=", "0", ")", "{", "if", "(", "IPv6AddressHelpers", ".", "isLessThanUnsigned", "(", "newLowBits", ",", "lowBits", ")", ")", "{", "// oops, we added something positive and the result is smaller -> overflow detected (carry over one bit from low to high)", "return", "new", "IPv6Address", "(", "highBits", "+", "1", ",", "newLowBits", ")", ";", "}", "else", "{", "// no overflow", "return", "new", "IPv6Address", "(", "highBits", ",", "newLowBits", ")", ";", "}", "}", "else", "{", "if", "(", "IPv6AddressHelpers", ".", "isLessThanUnsigned", "(", "lowBits", ",", "newLowBits", ")", ")", "{", "// oops, we added something negative and the result is bigger -> overflow detected (carry over one bit from high to low)", "return", "new", "IPv6Address", "(", "highBits", "-", "1", ",", "newLowBits", ")", ";", "}", "else", "{", "// no overflow", "return", "new", "IPv6Address", "(", "highBits", ",", "newLowBits", ")", ";", "}", "}", "}" ]

[ "Addition", ".", "Will", "never", "overflow", "but", "wraps", "around", "when", "the", "highest", "ip", "address", "has", "been", "reached", "." ]

[ "public", "IPv6Address", "subtract", "(", "int", "value", ")", "{", "final", "long", "newLowBits", "=", "lowBits", "-", "value", ";", "if", "(", "value", ">=", "0", ")", "{", "if", "(", "IPv6AddressHelpers", ".", "isLessThanUnsigned", "(", "lowBits", ",", "newLowBits", ")", ")", "{", "// oops, we subtracted something postive and the result is bigger -> overflow detected (carry over one bit from high to low)", "return", "new", "IPv6Address", "(", "highBits", "-", "1", ",", "newLowBits", ")", ";", "}", "else", "{", "// no overflow", "return", "new", "IPv6Address", "(", "highBits", ",", "newLowBits", ")", ";", "}", "}", "else", "{", "if", "(", "IPv6AddressHelpers", ".", "isLessThanUnsigned", "(", "newLowBits", ",", "lowBits", ")", ")", "{", "// oops, we subtracted something negative and the result is smaller -> overflow detected (carry over one bit from low to high)", "return", "new", "IPv6Address", "(", "highBits", "+", "1", ",", "newLowBits", ")", ";", "}", "else", "{", "// no overflow", "return", "new", "IPv6Address", "(", "highBits", ",", "newLowBits", ")", ";", "}", "}", "}" ]

[ "Subtraction", ".", "Will", "never", "underflow", "but", "wraps", "around", "when", "the", "lowest", "ip", "address", "has", "been", "reached", "." ]

[ "public", "IPv6Address", "maskWithNetworkMask", "(", "final", "IPv6NetworkMask", "networkMask", ")", "{", "if", "(", "networkMask", ".", "asPrefixLength", "(", ")", "==", "128", ")", "{", "return", "this", ";", "}", "else", "if", "(", "networkMask", ".", "asPrefixLength", "(", ")", "==", "64", ")", "{", "return", "new", "IPv6Address", "(", "this", ".", "highBits", ",", "0", ")", ";", "}", "else", "if", "(", "networkMask", ".", "asPrefixLength", "(", ")", "==", "0", ")", "{", "return", "new", "IPv6Address", "(", "0", ",", "0", ")", ";", "}", "else", "if", "(", "networkMask", ".", "asPrefixLength", "(", ")", ">", "64", ")", "{", "// apply mask on low bits only", "final", "int", "remainingPrefixLength", "=", "networkMask", ".", "asPrefixLength", "(", ")", "-", "64", ";", "return", "new", "IPv6Address", "(", "this", ".", "highBits", ",", "this", ".", "lowBits", "&", "(", "0xFFFFFFFFFFFFFFFF", "L", "<<", "(", "64", "-", "remainingPrefixLength", ")", ")", ")", ";", "}", "else", "{", "// apply mask on high bits, low bits completely 0", "return", "new", "IPv6Address", "(", "this", ".", "highBits", "&", "(", "0xFFFFFFFFFFFFFFFF", "L", "<<", "(", "64", "-", "networkMask", ".", "asPrefixLength", "(", ")", ")", ")", ",", "0", ")", ";", "}", "}" ]

[ "Mask", "the", "address", "with", "the", "given", "network", "mask", "." ]

[ "public", "IPv6Address", "setBit", "(", "final", "int", "bit", ")", "{", "if", "(", "bit", "<", "0", "||", "bit", ">", "127", ")", "throw", "new", "IllegalArgumentException", "(", "\"can only set bits in the interval [0, 127]\"", ")", ";", "if", "(", "bit", "<", "64", ")", "{", "return", "new", "IPv6Address", "(", "this", ".", "highBits", ",", "this", ".", "lowBits", "|", "(", "1L", "<<", "bit", ")", ")", ";", "}", "else", "{", "return", "new", "IPv6Address", "(", "this", ".", "highBits", "|", "(", "1L", "<<", "(", "bit", "-", "64", ")", ")", ",", "this", ".", "lowBits", ")", ";", "}", "}" ]

[ "Set", "a", "bit", "in", "the", "address", "." ]

[ "public", "void", "skipSafe", "(", "long", "numBytes", ")", "throws", "IOException", "{", "long", "skippedBytes", "=", "inputStream", ".", "skip", "(", "numBytes", ")", ";", "if", "(", "skippedBytes", "==", "-", "1", ")", "{", "throw", "new", "IOException", "(", "\"Could not skip '\"", "+", "numBytes", "+", "\"' bytes in stream\"", ")", ";", "}", "}" ]

[ "Skips", "over", "and", "discards", "numBytes", "bytes", "of", "data", "from", "the", "underlying", "input", "stream", ".", "Will", "throw", "an", "exception", "if", "the", "given", "number", "of", "bytes", "could", "not", "be", "skipped", "." ]

[ "public", "List", "<", "Group", ">", "getTopGroups", "(", ")", "{", "if", "(", "root", "!=", "null", "&&", "root", ".", "getGroups", "(", ")", "!=", "null", "&&", "root", ".", "getGroups", "(", ")", ".", "size", "(", ")", "==", "1", ")", "{", "return", "root", ".", "getGroups", "(", ")", ".", "get", "(", "0", ")", ".", "getGroups", "(", ")", ";", "}", "return", "new", "ArrayList", "<", "Group", ">", "(", ")", ";", "}" ]

[ "Retrieves", "all", "groups", "at", "the", "root", "level", "of", "a", "KeePass", "database", "." ]

[ "public", "List", "<", "Entry", ">", "getTopEntries", "(", ")", "{", "if", "(", "root", "!=", "null", "&&", "root", ".", "getGroups", "(", ")", "!=", "null", "&&", "root", ".", "getGroups", "(", ")", ".", "size", "(", ")", "==", "1", ")", "{", "return", "root", ".", "getGroups", "(", ")", ".", "get", "(", "0", ")", ".", "getEntries", "(", ")", ";", "}", "return", "new", "ArrayList", "<", "Entry", ">", "(", ")", ";", "}" ]

[ "Retrieves", "all", "entries", "at", "the", "root", "level", "of", "a", "KeePass", "database", "." ]

[ "public", "List", "<", "Entry", ">", "getEntries", "(", ")", "{", "List", "<", "Entry", ">", "allEntries", "=", "new", "ArrayList", "<", "Entry", ">", "(", ")", ";", "if", "(", "root", "!=", "null", ")", "{", "getEntries", "(", "root", ",", "allEntries", ")", ";", "}", "return", "allEntries", ";", "}" ]

[ "Retrieves", "a", "list", "of", "all", "entries", "in", "the", "KeePass", "database", "." ]

[ "public", "List", "<", "Group", ">", "getGroups", "(", ")", "{", "List", "<", "Group", ">", "allGroups", "=", "new", "ArrayList", "<", "Group", ">", "(", ")", ";", "if", "(", "root", "!=", "null", ")", "{", "getGroups", "(", "root", ",", "allGroups", ")", ";", "}", "return", "allGroups", ";", "}" ]

[ "Retrieves", "a", "list", "of", "all", "groups", "in", "the", "KeePass", "database", "." ]

[ "public", "Entry", "getEntryByUUID", "(", "final", "UUID", "UUID", ")", "{", "List", "<", "Entry", ">", "allEntries", "=", "getEntries", "(", ")", ";", "List", "<", "Entry", ">", "entries", "=", "ListFilter", ".", "filter", "(", "allEntries", ",", "new", "Filter", "<", "Entry", ">", "(", ")", "{", "@", "Override", "public", "boolean", "matches", "(", "Entry", "item", ")", "{", "if", "(", "item", ".", "getUuid", "(", ")", "!=", "null", "&&", "item", ".", "getUuid", "(", ")", ".", "compareTo", "(", "UUID", ")", "==", "0", ")", "{", "return", "true", ";", "}", "else", "{", "return", "false", ";", "}", "}", "}", ")", ";", "if", "(", "entries", ".", "size", "(", ")", "==", "1", ")", "{", "return", "entries", ".", "get", "(", "0", ")", ";", "}", "else", "{", "return", "null", ";", "}", "}" ]

[ "Retrieves", "an", "entry", "based", "on", "its", "UUID", "." ]

[ "public", "Group", "getGroupByUUID", "(", "final", "UUID", "UUID", ")", "{", "List", "<", "Group", ">", "allGroups", "=", "getGroups", "(", ")", ";", "List", "<", "Group", ">", "groups", "=", "ListFilter", ".", "filter", "(", "allGroups", ",", "new", "Filter", "<", "Group", ">", "(", ")", "{", "@", "Override", "public", "boolean", "matches", "(", "Group", "item", ")", "{", "if", "(", "item", ".", "getUuid", "(", ")", "!=", "null", "&&", "item", ".", "getUuid", "(", ")", ".", "compareTo", "(", "UUID", ")", "==", "0", ")", "{", "return", "true", ";", "}", "else", "{", "return", "false", ";", "}", "}", "}", ")", ";", "if", "(", "groups", ".", "size", "(", ")", "==", "1", ")", "{", "return", "groups", ".", "get", "(", "0", ")", ";", "}", "else", "{", "return", "null", ";", "}", "}" ]

[ "Retrieves", "a", "group", "based", "on", "its", "UUID", "." ]

[ "public", "static", "KeePassDatabase", "getInstance", "(", "File", "keePassDatabaseFile", ")", "{", "if", "(", "keePassDatabaseFile", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"You must provide a valid KeePass database file.\"", ")", ";", "}", "InputStream", "keePassDatabaseStream", "=", "null", ";", "try", "{", "keePassDatabaseStream", "=", "new", "FileInputStream", "(", "keePassDatabaseFile", ")", ";", "return", "getInstance", "(", "keePassDatabaseStream", ")", ";", "}", "catch", "(", "FileNotFoundException", "e", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"The KeePass database file could not be found. You must provide a valid KeePass database file.\"", ",", "e", ")", ";", "}", "finally", "{", "if", "(", "keePassDatabaseStream", "!=", "null", ")", "{", "try", "{", "keePassDatabaseStream", ".", "close", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "// Ignore\r", "}", "}", "}", "}" ]

[ "Retrieves", "a", "KeePassDatabase", "instance", ".", "The", "instance", "returned", "is", "based", "on", "the", "given", "database", "file", "and", "tries", "to", "parse", "the", "database", "header", "of", "it", "." ]

[ "public", "Entry", "getEntryByTitle", "(", "String", "title", ")", "{", "for", "(", "Entry", "entry", ":", "entries", ")", "{", "if", "(", "entry", ".", "getTitle", "(", ")", ".", "equalsIgnoreCase", "(", "title", ")", ")", "{", "return", "entry", ";", "}", "}", "return", "null", ";", "}" ]

[ "Retrieves", "the", "entry", "with", "the", "given", "title", "." ]

[ "public", "KeePassFile", "enrichNodesWithIconData", "(", "KeePassFile", "keePassFile", ")", "{", "CustomIcons", "iconLibrary", "=", "keePassFile", ".", "getMeta", "(", ")", ".", "getCustomIcons", "(", ")", ";", "GroupZipper", "zipper", "=", "new", "GroupZipper", "(", "keePassFile", ")", ";", "Iterator", "<", "Group", ">", "iter", "=", "zipper", ".", "iterator", "(", ")", ";", "while", "(", "iter", ".", "hasNext", "(", ")", ")", "{", "Group", "group", "=", "iter", ".", "next", "(", ")", ";", "byte", "[", "]", "iconData", "=", "getIconData", "(", "group", ".", "getCustomIconUuid", "(", ")", ",", "group", ".", "getIconId", "(", ")", ",", "iconLibrary", ")", ";", "Group", "groupWithIcon", "=", "new", "GroupBuilder", "(", "group", ")", ".", "iconData", "(", "iconData", ")", ".", "build", "(", ")", ";", "zipper", ".", "replace", "(", "groupWithIcon", ")", ";", "enrichEntriesWithIcons", "(", "iconLibrary", ",", "group", ")", ";", "}", "return", "zipper", ".", "close", "(", ")", ";", "}" ]

[ "Iterates", "through", "all", "nodes", "of", "the", "given", "KeePass", "file", "and", "replace", "the", "nodes", "with", "enriched", "icon", "data", "nodes", "." ]

[ "public", "Binary", "getBinaryById", "(", "int", "id", ")", "{", "for", "(", "Binary", "binary", ":", "binaryList", ")", "{", "if", "(", "binary", ".", "getId", "(", ")", "==", "id", ")", "{", "return", "binary", ";", "}", "}", "return", "null", ";", "}" ]

[ "Retrieves", "a", "binary", "item", "based", "on", "its", "id", "." ]

[ "public", "IPv6AddressRange", "extend", "(", "IPv6Address", "address", ")", "{", "if", "(", "address", ".", "compareTo", "(", "first", ")", "<", "0", ")", "return", "fromFirstAndLast", "(", "address", ",", "last", ")", ";", "else", "if", "(", "address", ".", "compareTo", "(", "last", ")", ">", "0", ")", "return", "fromFirstAndLast", "(", "first", ",", "address", ")", ";", "else", "return", "this", ";", "}" ]

[ "Extend", "the", "range", "just", "enough", "at", "its", "head", "or", "tail", "such", "that", "the", "given", "address", "is", "included", "." ]

[ "public", "Entry", "buildWithHistory", "(", ")", "{", "if", "(", "originalEntry", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"originalEntry is not set\"", ")", ";", "}", "if", "(", "history", "==", "null", ")", "{", "history", "=", "new", "History", "(", ")", ";", "}", "Entry", "entryWithoutHistory", "=", "new", "EntryBuilder", "(", "originalEntry", ")", ".", "history", "(", "new", "History", "(", ")", ")", ".", "build", "(", ")", ";", "history", ".", "getHistoricEntries", "(", ")", ".", "add", "(", "entryWithoutHistory", ")", ";", "return", "build", "(", ")", ";", "}" ]

[ "Builds", "a", "new", "entry", "and", "place", "the", "original", "one", "in", "the", "history", "list", "." ]

[ "public", "CustomIcon", "getIconByUuid", "(", "UUID", "uuid", ")", "{", "for", "(", "CustomIcon", "customIcon", ":", "customIconList", ")", "{", "if", "(", "customIcon", ".", "getUuid", "(", ")", "!=", "null", "&&", "customIcon", ".", "getUuid", "(", ")", ".", "compareTo", "(", "uuid", ")", "==", "0", ")", "{", "return", "customIcon", ";", "}", "}", "return", "null", ";", "}" ]

[ "Retrieves", "a", "custom", "icon", "based", "on", "its", "uuid", "." ]

[ "public", "IPv6AddressPool", "allocate", "(", ")", "{", "if", "(", "!", "isExhausted", "(", ")", ")", "{", "// get the first range of free subnets, and take the first subnet of that range", "final", "IPv6AddressRange", "firstFreeRange", "=", "freeRanges", ".", "first", "(", ")", ";", "final", "IPv6Network", "allocated", "=", "IPv6Network", ".", "fromAddressAndMask", "(", "firstFreeRange", ".", "getFirst", "(", ")", ",", "allocationSubnetSize", ")", ";", "return", "doAllocate", "(", "allocated", ",", "firstFreeRange", ")", ";", "}", "else", "{", "// exhausted", "return", "null", ";", "}", "}" ]

[ "Allocate", "the", "first", "available", "subnet", "from", "the", "pool", "." ]

[ "public", "IPv6AddressPool", "allocate", "(", "IPv6Network", "toAllocate", ")", "{", "if", "(", "!", "contains", "(", "toAllocate", ")", ")", "throw", "new", "IllegalArgumentException", "(", "\"can not allocate network which is not contained in the pool to allocate from [\"", "+", "toAllocate", "+", "\"]\"", ")", ";", "if", "(", "!", "this", ".", "allocationSubnetSize", ".", "equals", "(", "toAllocate", ".", "getNetmask", "(", ")", ")", ")", "throw", "new", "IllegalArgumentException", "(", "\"can not allocate network with prefix length /\"", "+", "toAllocate", ".", "getNetmask", "(", ")", ".", "asPrefixLength", "(", ")", "+", "\" from a pool configured to hand out subnets with prefix length /\"", "+", "allocationSubnetSize", ")", ";", "// go find the range that contains the requested subnet", "final", "IPv6AddressRange", "rangeToAllocateFrom", "=", "findFreeRangeContaining", "(", "toAllocate", ")", ";", "if", "(", "rangeToAllocateFrom", "!=", "null", ")", "{", "// found a range in which this subnet is free, allocate it", "return", "doAllocate", "(", "toAllocate", ",", "rangeToAllocateFrom", ")", ";", "}", "else", "{", "// requested subnet not free", "return", "null", ";", "}", "}" ]

[ "Allocate", "the", "given", "subnet", "from", "the", "pool", "." ]

[ "private", "IPv6AddressPool", "doAllocate", "(", "final", "IPv6Network", "toAllocate", ",", "final", "IPv6AddressRange", "rangeToAllocateFrom", ")", "{", "assert", "freeRanges", ".", "contains", "(", "rangeToAllocateFrom", ")", ";", "assert", "rangeToAllocateFrom", ".", "contains", "(", "toAllocate", ")", ";", "final", "TreeSet", "<", "IPv6AddressRange", ">", "newFreeRanges", "=", "new", "TreeSet", "<", "IPv6AddressRange", ">", "(", "this", ".", "freeRanges", ")", ";", "// remove range from free ranges", "newFreeRanges", ".", "remove", "(", "rangeToAllocateFrom", ")", ";", "// from the range, remove the allocated subnet", "final", "List", "<", "IPv6AddressRange", ">", "newRanges", "=", "rangeToAllocateFrom", ".", "remove", "(", "toAllocate", ")", ";", "// and add the resulting ranges as new free ranges", "newFreeRanges", ".", "addAll", "(", "newRanges", ")", ";", "return", "new", "IPv6AddressPool", "(", "underlyingRange", ",", "allocationSubnetSize", ",", "newFreeRanges", ",", "toAllocate", ")", ";", "}" ]

[ "Private", "helper", "method", "to", "perform", "the", "allocation", "of", "a", "subnet", "within", "one", "of", "the", "free", "ranges", "." ]

[ "private", "IPv6AddressRange", "findFreeRangeBefore", "(", "IPv6Network", "network", ")", "{", "for", "(", "IPv6AddressRange", "freeRange", ":", "freeRanges", ")", "{", "if", "(", "freeRange", ".", "getLast", "(", ")", ".", "add", "(", "1", ")", ".", "equals", "(", "network", ".", "getFirst", "(", ")", ")", ")", "{", "return", "freeRange", ";", "}", "}", "// not found", "return", "null", ";", "}" ]

[ "Private", "helper", "method", "to", "find", "the", "free", "range", "just", "before", "the", "given", "network", "." ]

[ "private", "IPv6AddressRange", "findFreeRangeAfter", "(", "IPv6Network", "network", ")", "{", "for", "(", "IPv6AddressRange", "freeRange", ":", "freeRanges", ")", "{", "if", "(", "freeRange", ".", "getFirst", "(", ")", ".", "subtract", "(", "1", ")", ".", "equals", "(", "network", ".", "getLast", "(", ")", ")", ")", "{", "return", "freeRange", ";", "}", "}", "// not found", "return", "null", ";", "}" ]

[ "Private", "helper", "method", "to", "find", "the", "free", "range", "just", "after", "the", "given", "address", "." ]

[ "public", "boolean", "canRight", "(", ")", "{", "if", "(", "parent", "==", "null", ")", "{", "return", "false", ";", "}", "if", "(", "index", "+", "1", ">=", "parent", ".", "getNode", "(", ")", ".", "getGroups", "(", ")", ".", "size", "(", ")", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Returns", "true", "if", "it", "is", "possible", "to", "navigate", "right", "." ]

[ "public", "GroupZipper", "right", "(", ")", "{", "if", "(", "!", "canRight", "(", ")", ")", "{", "throw", "new", "NoSuchElementException", "(", "\"Could not move right because the last node at this level has already been reached\"", ")", ";", "}", "index", "++", ";", "node", "=", "parent", ".", "getNode", "(", ")", ".", "getGroups", "(", ")", ".", "get", "(", "index", ")", ";", "return", "this", ";", "}" ]

[ "Navigates", "right", "the", "tree", "to", "the", "next", "node", "at", "the", "same", "level", "." ]

[ "public", "GroupZipper", "left", "(", ")", "{", "if", "(", "!", "canLeft", "(", ")", ")", "{", "throw", "new", "NoSuchElementException", "(", "\"Could not move left because the first node at this level has already been reached\"", ")", ";", "}", "index", "--", ";", "node", "=", "parent", ".", "getNode", "(", ")", ".", "getGroups", "(", ")", ".", "get", "(", "index", ")", ";", "return", "this", ";", "}" ]

[ "Navigates", "left", "the", "tree", "to", "the", "previous", "node", "at", "the", "same", "level", "." ]

[ "public", "T", "[", "]", "simplify", "(", "T", "[", "]", "points", ",", "double", "tolerance", ",", "boolean", "highestQuality", ")", "{", "if", "(", "points", "==", "null", "||", "points", ".", "length", "<=", "2", ")", "{", "return", "points", ";", "}", "double", "sqTolerance", "=", "tolerance", "*", "tolerance", ";", "if", "(", "!", "highestQuality", ")", "{", "points", "=", "simplifyRadialDistance", "(", "points", ",", "sqTolerance", ")", ";", "}", "points", "=", "simplifyDouglasPeucker", "(", "points", ",", "sqTolerance", ")", ";", "return", "points", ";", "}" ]

[ "Simplifies", "a", "list", "of", "points", "to", "a", "shorter", "list", "of", "points", "." ]

[ "public", "static", "boolean", "migrate", "(", "final", "Session", "session", ",", "final", "MigrationResources", "resources", ")", "{", "return", "MigrationEngine", ".", "withSession", "(", "session", ")", ".", "migrate", "(", "resources", ")", ";", "}" ]

[ "Execute", "all", "migrations", "in", "migration", "resource", "collection", "." ]

[ "public", "int", "getCurrentVersion", "(", "final", "MigrationType", "type", ")", "{", "final", "Statement", "select", "=", "QueryBuilder", ".", "select", "(", ")", ".", "all", "(", ")", ".", "from", "(", "SCHEMA_VERSION_CF", ")", ".", "where", "(", "QueryBuilder", ".", "eq", "(", "TYPE", ",", "type", ".", "name", "(", ")", ")", ")", ".", "limit", "(", "1", ")", ".", "setConsistencyLevel", "(", "ConsistencyLevel", ".", "ALL", ")", ";", "final", "ResultSet", "result", "=", "session", ".", "execute", "(", "select", ")", ";", "final", "Row", "row", "=", "result", ".", "one", "(", ")", ";", "return", "row", "==", "null", "?", "0", ":", "row", ".", "getInt", "(", "VERSION", ")", ";", "}" ]

[ "Get", "current", "database", "version", "for", "given", "migration", "type", "with", "ALL", "consistency", ".", "Select", "one", "row", "since", "migration", "history", "is", "saved", "ordered", "descending", "by", "timestamp", ".", "If", "there", "are", "no", "rows", "in", "the", "schema_version", "table", "return", "0", "as", "default", "database", "version", ".", "Data", "version", "is", "changed", "by", "executing", "migrations", "." ]

[ "public", "boolean", "updateVersion", "(", "final", "Migration", "migration", ")", "{", "final", "Statement", "insert", "=", "QueryBuilder", ".", "insertInto", "(", "SCHEMA_VERSION_CF", ")", ".", "value", "(", "TYPE", ",", "migration", ".", "getType", "(", ")", ".", "name", "(", ")", ")", ".", "value", "(", "VERSION", ",", "migration", ".", "getVersion", "(", ")", ")", ".", "value", "(", "TIMESTAMP", ",", "System", ".", "currentTimeMillis", "(", ")", ")", ".", "value", "(", "DESCRIPTION", ",", "migration", ".", "getDescription", "(", ")", ")", ".", "setConsistencyLevel", "(", "ConsistencyLevel", ".", "ALL", ")", ";", "try", "{", "session", ".", "execute", "(", "insert", ")", ";", "return", "true", ";", "}", "catch", "(", "final", "Exception", "e", ")", "{", "LOGGER", ".", "error", "(", "\"Failed to execute update version statement\"", ",", "e", ")", ";", "return", "false", ";", "}", "}" ]

[ "Update", "current", "database", "version", "to", "the", "migration", "version", ".", "This", "is", "executed", "after", "migration", "success", "." ]

[ "protected", "void", "executeWithSchemaAgreement", "(", "Statement", "statement", ")", "throws", "SchemaAgreementException", "{", "ResultSet", "result", "=", "this", ".", "session", ".", "execute", "(", "statement", ")", ";", "if", "(", "checkSchemaAgreement", "(", "result", ")", ")", "{", "return", ";", "}", "if", "(", "checkClusterSchemaAgreement", "(", ")", ")", "{", "return", ";", "}", "throw", "new", "SchemaAgreementException", "(", "\"Failed to propagate schema update to all nodes (schema agreement error)\"", ")", ";", "}" ]

[ "Execute", "provided", "statement", "and", "checks", "if", "the", "schema", "migration", "has", "been", "propagated", "to", "all", "nodes", "in", "the", "cluster", ".", "Use", "this", "method", "when", "executing", "schema", "migrations", "." ]

[ "@", "Bean", "@", "ConditionalOnMissingBean", "(", "AuthenticationInformationRetriever", ".", "class", ")", "public", "AuthenticationInformationRetriever", "<", "HodAuthentication", "<", "EntityType", ".", "Combined", ">", ",", "HodAuthenticationPrincipal", ">", "authenticationInformationRetriever", "(", ")", "{", "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "final", "AuthenticationInformationRetriever", "<", "HodAuthentication", "<", "EntityType", ".", "Combined", ">", ",", "HodAuthenticationPrincipal", ">", "retriever", "=", "new", "SpringSecurityAuthenticationInformationRetriever", "<>", "(", "(", "Class", "<", "HodAuthentication", "<", "EntityType", ".", "Combined", ">", ">", ")", "(", "Class", "<", "?", ">", ")", "HodAuthentication", ".", "class", ",", "HodAuthenticationPrincipal", ".", "class", ")", ";", "return", "retriever", ";", "}" ]

[ "Note", "that", "this", "bean", "cannot", "go", "in", "HavenSearchHodApplication", "because", "it", "would", "then", "cause", "a", "circular", "dependency", "in", "upstream", "applications" ]

[ "@", "Nonnull", "public", "static", "final", "<", "T", ">", "JPAExecutionResult", "<", "T", ">", "doSelectStatic", "(", "@", "Nonnull", "final", "Callable", "<", "T", ">", "aCallable", ")", "{", "ValueEnforcer", ".", "notNull", "(", "aCallable", ",", "\"Callable\"", ")", ";", "final", "StopWatch", "aSW", "=", "StopWatch", ".", "createdStarted", "(", ")", ";", "try", "{", "// Call callback", "final", "T", "ret", "=", "aCallable", ".", "call", "(", ")", ";", "s_aStatsCounterSuccess", ".", "increment", "(", ")", ";", "s_aStatsTimerExecutionSuccess", ".", "addTime", "(", "aSW", ".", "stopAndGetMillis", "(", ")", ")", ";", "return", "JPAExecutionResult", ".", "createSuccess", "(", "ret", ")", ";", "}", "catch", "(", "final", "Exception", "ex", ")", "{", "s_aStatsCounterError", ".", "increment", "(", ")", ";", "s_aStatsTimerExecutionError", ".", "addTime", "(", "aSW", ".", "stopAndGetMillis", "(", ")", ")", ";", "_invokeCustomExceptionCallback", "(", "ex", ")", ";", "return", "JPAExecutionResult", ".", "<", "T", ">", "createFailure", "(", "ex", ")", ";", "}", "finally", "{", "if", "(", "isDefaultExecutionWarnTimeEnabled", "(", ")", ")", "if", "(", "aSW", ".", "getMillis", "(", ")", ">", "getDefaultExecutionWarnTime", "(", ")", ")", "onExecutionTimeExceeded", "(", "\"Execution of select took too long: \"", "+", "aCallable", ".", "toString", "(", ")", ",", "aSW", ".", "getMillis", "(", ")", ")", ";", "}", "}" ]

[ "Perform", "a", "select", "without", "a", "transaction" ]

[ "@", "Nonnull", "public", "final", "<", "T", ">", "JPAExecutionResult", "<", "T", ">", "doSelect", "(", "@", "Nonnull", "final", "Callable", "<", "T", ">", "aCallable", ")", "{", "if", "(", "isUseTransactionsForSelect", "(", ")", ")", "{", "// Use transactions for select statement!", "return", "doInTransaction", "(", "aCallable", ")", ";", "}", "// Ensure that only one transaction is active for all users!", "final", "EntityManager", "aEntityMgr", "=", "getEntityManager", "(", ")", ";", "if", "(", "!", "isSyncEntityMgr", "(", ")", ")", "{", "// No synchronization required", "return", "doSelectStatic", "(", "aCallable", ")", ";", "}", "// Sync on the whole entity manager, to have a cross-manager", "// synchronization!", "synchronized", "(", "aEntityMgr", ")", "{", "return", "doSelectStatic", "(", "aCallable", ")", ";", "}", "}" ]

[ "Run", "a", "read", "-", "only", "query", ".", "By", "default", "no", "transaction", "is", "used", "and", "the", "entity", "manager", "is", "synchronized", "." ]

[ "public", "String", "getPropertyValue", "(", "String", "key", ")", "{", "checkArgument", "(", "!", "Strings", ".", "isNullOrEmpty", "(", "key", ")", ",", "\"key\"", ")", ";", "String", "errorMessage", "=", "String", ".", "format", "(", "\"Failed to retrieve %s property from Conqueso server: %s\"", ",", "key", ",", "conquesoUrl", ".", "toExternalForm", "(", ")", ")", ";", "return", "readStringFromUrl", "(", "\"properties/\"", "+", "key", ",", "errorMessage", ")", ";", "}" ]

[ "Retrieve", "the", "latest", "value", "for", "the", "given", "property", "key", "from", "the", "Conqueso", "Server", "returned", "as", "a", "String", "." ]

[ "public", "ImmutableList", "<", "RoleInfo", ">", "getRoles", "(", ")", "{", "TypeReference", "<", "List", "<", "RoleInfo", ">>", "typeReference", "=", "new", "TypeReference", "<", "List", "<", "RoleInfo", ">", ">", "(", ")", "{", "}", ";", "String", "errorMessage", "=", "String", ".", "format", "(", "\"Failed to retrieve roles from Conqueso server: %s\"", ",", "conquesoUrl", ".", "toExternalForm", "(", ")", ")", ";", "return", "ImmutableList", ".", "copyOf", "(", "readObjectFromJson", "(", "typeReference", ",", "\"/api/roles\"", ",", "errorMessage", ")", ")", ";", "}" ]

[ "Retrieve", "information", "about", "the", "roles", "from", "the", "Conqueso", "Server", "." ]

[ "public", "ImmutableList", "<", "InstanceInfo", ">", "getRoleInstances", "(", "String", "roleName", ")", "{", "return", "getRoleInstancesWithMetadataImpl", "(", "roleName", ",", "Collections", ".", "<", "String", ",", "String", ">", "emptyMap", "(", ")", ")", ";", "}" ]

[ "Retrieve", "information", "about", "instances", "of", "a", "particular", "role", "from", "the", "Conqueso", "Server", "." ]

[ "protected", "final", "void", "checkNotNull", "(", "final", "ConversionStringency", "stringency", ",", "final", "Logger", "logger", ")", "{", "if", "(", "stringency", "==", "null", ")", "{", "throw", "new", "NullPointerException", "(", "\"stringency must not be null\"", ")", ";", "}", "if", "(", "logger", "==", "null", ")", "{", "throw", "new", "NullPointerException", "(", "\"logger must not be null\"", ")", ";", "}", "}" ]

[ "Check", "the", "specified", "conversion", "stringency", "and", "logger", "are", "not", "null", "." ]

[ "protected", "final", "void", "warnOrThrow", "(", "final", "S", "source", ",", "final", "String", "message", ",", "final", "Throwable", "cause", ",", "final", "ConversionStringency", "stringency", ",", "final", "Logger", "logger", ")", "throws", "ConversionException", "{", "checkNotNull", "(", "stringency", ",", "logger", ")", ";", "if", "(", "stringency", ".", "isLenient", "(", ")", ")", "{", "if", "(", "cause", "!=", "null", ")", "{", "logger", ".", "warn", "(", "String", ".", "format", "(", "\"could not convert %s to %s, %s\"", ",", "sourceClass", ".", "toString", "(", ")", ",", "targetClass", ".", "toString", "(", ")", ",", "message", ")", ",", "cause", ")", ";", "}", "else", "{", "logger", ".", "warn", "(", "\"could not convert {} to {}, {}\"", ",", "sourceClass", ".", "toString", "(", ")", ",", "targetClass", ".", "toString", "(", ")", ",", "message", ")", ";", "}", "}", "else", "if", "(", "stringency", ".", "isStrict", "(", ")", ")", "{", "throw", "new", "ConversionException", "(", "String", ".", "format", "(", "\"could not convert %s to %s, %s\"", ",", "sourceClass", ".", "toString", "(", ")", ",", "targetClass", ".", "toString", "(", ")", ",", "message", ")", ",", "cause", ",", "source", ",", "sourceClass", ",", "targetClass", ")", ";", "}", "}" ]

[ "If", "the", "conversion", "stringency", "is", "lenient", "log", "a", "warning", "with", "the", "specified", "message", "or", "if", "the", "conversion", "stringency", "is", "strict", "throw", "a", "ConversionException", "with", "the", "specified", "message", "and", "cause", "." ]

[ "@", "Nonnull", "@", "Nonempty", "public", "static", "String", "buildJDBCString", "(", "@", "Nonnull", "@", "Nonempty", "final", "String", "sJdbcURL", ",", "@", "Nullable", "final", "Map", "<", "EMySQLConnectionProperty", ",", "String", ">", "aConnectionProperties", ")", "{", "ValueEnforcer", ".", "notEmpty", "(", "sJdbcURL", ",", "\"JDBC URL\"", ")", ";", "ValueEnforcer", ".", "isTrue", "(", "sJdbcURL", ".", "startsWith", "(", "CJDBC_MySQL", ".", "CONNECTION_PREFIX", ")", ",", "\"The JDBC URL '\"", "+", "sJdbcURL", "+", "\"' does not seem to be a MySQL connection string!\"", ")", ";", "// Add the connection properties to the JDBC string", "final", "SimpleURL", "aURL", "=", "new", "SimpleURL", "(", "sJdbcURL", ")", ";", "if", "(", "aConnectionProperties", "!=", "null", ")", "for", "(", "final", "Map", ".", "Entry", "<", "EMySQLConnectionProperty", ",", "String", ">", "aEntry", ":", "aConnectionProperties", ".", "entrySet", "(", ")", ")", "aURL", ".", "(", "aEntry", ".", "getKey", "(", ")", ".", "getName", "(", ")", ",", "aEntry", ".", "getValue", "(", ")", ")", ";", "return", "aURL", ".", "getAsStringWithoutEncodedParameters", "(", ")", ";", "}" ]

[ "Build", "the", "final", "connection", "string", "from", "the", "base", "JDBC", "URL", "and", "an", "optional", "set", "of", "connection", "properties", "." ]

[ "public", "Pattern", "updatePattern", "(", "final", "Collection", "<", "String", ">", "prefixes", ")", "{", "final", "String", "XML_PREFIX", "=", "prefixes", ".", "stream", "(", ")", ".", "map", "(", "s", "->", "Pattern", ".", "quote", "(", "s", "+", "\"/\"", ")", ")", ".", "collect", "(", "Collectors", ".", "joining", "(", "\"|\"", ")", ")", ";", "return", "XML_PATH_PATTERN", "=", "Pattern", ".", "compile", "(", "\"^/?(?:\"", "+", "XML_PREFIX", "+", "\")?(?:\"", "+", "IDX_PREFIX", "+", "\")?(?<fieldPath>[^/]+(?:/[^/]+)*)$\"", ")", ";", "}" ]

[ "We", "have", "to", "do", "it", "this", "way", "to", "break", "the", "circular", "dependency", "between", "the", "FieldsInfo", "deserializer", "and", "this", "." ]

[ "public", "static", "String", "resolveTitle", "(", "final", "String", "title", ",", "final", "String", "reference", ")", "{", "if", "(", "StringUtils", ".", "isBlank", "(", "title", ")", "&&", "!", "StringUtils", ".", "isBlank", "(", "reference", ")", ")", "{", "// If there is no title, assume the reference is a path and take the last part (the \"file name\")", "final", "String", "[", "]", "splitReference", "=", "PATH_SEPARATOR_REGEX", ".", "split", "(", "reference", ")", ";", "final", "String", "lastPart", "=", "splitReference", "[", "splitReference", ".", "length", "-", "1", "]", ";", "return", "StringUtils", ".", "isBlank", "(", "lastPart", ")", "||", "reference", ".", "endsWith", "(", "\"/\"", ")", "||", "reference", ".", "endsWith", "(", "\"\\\\\"", ")", "?", "reference", ":", "lastPart", ";", "}", "else", "{", "return", "title", ";", "}", "}" ]

[ "Determine", "a", "title", "to", "use", "for", "a", "document", "given", "it", "s", "title", "and", "reference", "fields", "." ]

[ "public", "static", "int", "getJDBCTypeFromClass", "(", "@", "Nonnull", "final", "Class", "<", "?", ">", "aClass", ")", "{", "ValueEnforcer", ".", "notNull", "(", "aClass", ",", "\"Class\"", ")", ";", "if", "(", "!", "ClassHelper", ".", "isArrayClass", "(", "aClass", ")", ")", "{", "// CHAR, VARCHAR or LONGVARCHAR", "if", "(", "aClass", ".", "equals", "(", "String", ".", "class", ")", ")", "return", "Types", ".", "VARCHAR", ";", "if", "(", "aClass", ".", "equals", "(", "BigDecimal", ".", "class", ")", ")", "return", "Types", ".", "NUMERIC", ";", "// BIT or BOOLEAN", "if", "(", "aClass", ".", "equals", "(", "Boolean", ".", "class", ")", "||", "aClass", ".", "equals", "(", "boolean", ".", "class", ")", ")", "return", "Types", ".", "BOOLEAN", ";", "if", "(", "aClass", ".", "equals", "(", "Byte", ".", "class", ")", "||", "aClass", ".", "equals", "(", "byte", ".", "class", ")", ")", "return", "Types", ".", "TINYINT", ";", "if", "(", "aClass", ".", "equals", "(", "Character", ".", "class", ")", "||", "aClass", ".", "equals", "(", "char", ".", "class", ")", ")", "return", "Types", ".", "CHAR", ";", "if", "(", "aClass", ".", "equals", "(", "Double", ".", "class", ")", "||", "aClass", ".", "equals", "(", "double", ".", "class", ")", ")", "return", "Types", ".", "DOUBLE", ";", "if", "(", "aClass", ".", "equals", "(", "Float", ".", "class", ")", "||", "aClass", ".", "equals", "(", "float", ".", "class", ")", ")", "return", "Types", ".", "REAL", ";", "if", "(", "aClass", ".", "equals", "(", "Integer", ".", "class", ")", "||", "aClass", ".", "equals", "(", "int", ".", "class", ")", ")", "return", "Types", ".", "INTEGER", ";", "if", "(", "aClass", ".", "equals", "(", "Long", ".", "class", ")", "||", "aClass", ".", "equals", "(", "long", ".", "class", ")", ")", "return", "Types", ".", "BIGINT", ";", "if", "(", "aClass", ".", "equals", "(", "Short", ".", "class", ")", "||", "aClass", ".", "equals", "(", "short", ".", "class", ")", ")", "return", "Types", ".", "SMALLINT", ";", "if", "(", "aClass", ".", "equals", "(", "java", ".", "sql", ".", "Date", ".", "class", ")", ")", "return", "Types", ".", "DATE", ";", "if", "(", "aClass", ".", "equals", "(", "java", ".", "sql", ".", "Time", ".", "class", ")", ")", "return", "Types", ".", "TIME", ";", "if", "(", "aClass", ".", "equals", "(", "java", ".", "sql", ".", "Timestamp", ".", "class", ")", ")", "return", "Types", ".", "TIMESTAMP", ";", "if", "(", "aClass", ".", "equals", "(", "java", ".", "time", ".", "ZonedDateTime", ".", "class", ")", ")", "return", "Types", ".", "TIMESTAMP", ";", "if", "(", "aClass", ".", "equals", "(", "java", ".", "time", ".", "OffsetDateTime", ".", "class", ")", ")", "return", "Types", ".", "TIMESTAMP", ";", "if", "(", "aClass", ".", "equals", "(", "java", ".", "time", ".", "LocalDateTime", ".", "class", ")", ")", "return", "Types", ".", "TIMESTAMP", ";", "if", "(", "aClass", ".", "equals", "(", "java", ".", "time", ".", "LocalDate", ".", "class", ")", ")", "return", "Types", ".", "DATE", ";", "if", "(", "aClass", ".", "equals", "(", "java", ".", "time", ".", "LocalTime", ".", "class", ")", ")", "return", "Types", ".", "TIME", ";", "}", "else", "{", "final", "Class", "<", "?", ">", "aComponentType", "=", "aClass", ".", "getComponentType", "(", ")", ";", "if", "(", "aComponentType", ".", "equals", "(", "byte", ".", "class", ")", ")", "return", "Types", ".", "VARBINARY", ";", "}", "LOGGER", ".", "warn", "(", "\"Failed to resolve JDBC type from class \"", "+", "aClass", ".", "getName", "(", ")", ")", ";", "return", "Types", ".", "JAVA_OBJECT", ";", "}" ]

[ "Determine", "the", "JDBC", "type", "from", "the", "passed", "class", "." ]

[ "@", "Nonnull", "public", "final", "ESuccess", "dumpDatabase", "(", "@", "Nonnull", "@", "WillClose", "final", "OutputStream", "aOS", ")", "{", "ValueEnforcer", ".", "notNull", "(", "aOS", ",", "\"OutputStream\"", ")", ";", "// Save the DB data to an SQL file", "try", "{", "LOGGER", ".", "info", "(", "\"Dumping database '\"", "+", "getDatabaseName", "(", ")", "+", "\"' to OutputStream\"", ")", ";", "try", "(", "final", "PrintWriter", "aPrintWriter", "=", "new", "PrintWriter", "(", "new", "NonBlockingBufferedWriter", "(", "StreamHelper", ".", "createWriter", "(", "aOS", ",", "StandardCharsets", ".", "UTF_8", ")", ")", ")", ")", "{", "final", "DBExecutor", "aExecutor", "=", "new", "DBExecutor", "(", "this", ")", ";", "final", "ESuccess", "ret", "=", "aExecutor", ".", "queryAll", "(", "\"SCRIPT SIMPLE\"", ",", "aCurrentObject", "->", "{", "if", "(", "aCurrentObject", "!=", "null", ")", "{", "// The value of the first column is the script line", "aPrintWriter", ".", "println", "(", "aCurrentObject", ".", "get", "(", "0", ")", ".", "getValue", "(", ")", ")", ";", "}", "}", ")", ";", "aPrintWriter", ".", "flush", "(", ")", ";", "return", "ret", ";", "}", "}", "finally", "{", "StreamHelper", ".", "close", "(", "aOS", ")", ";", "}", "}" ]

[ "Dump", "the", "database", "to", "the", "passed", "output", "stream", "and", "closed", "the", "passed", "output", "stream", "." ]

[ "@", "Nonnull", "public", "final", "ESuccess", "createBackup", "(", "@", "Nonnull", "final", "File", "fDestFile", ")", "{", "ValueEnforcer", ".", "notNull", "(", "fDestFile", ",", "\"DestFile\"", ")", ";", "LOGGER", ".", "info", "(", "\"Backing up database '\"", "+", "getDatabaseName", "(", ")", "+", "\"' to \"", "+", "fDestFile", ")", ";", "final", "DBExecutor", "aExecutor", "=", "new", "DBExecutor", "(", "this", ")", ";", "return", "aExecutor", ".", "executeStatement", "(", "\"BACKUP TO '\"", "+", "fDestFile", ".", "getAbsolutePath", "(", ")", "+", "\"'\"", ")", ";", "}" ]

[ "Create", "a", "backup", "file", ".", "The", "file", "is", "a", "ZIP", "file", "." ]

[ "private", "HodSearchResult", "addDomain", "(", "final", "Iterable", "<", "ResourceName", ">", "indexIdentifiers", ",", "final", "HodSearchResult", "document", ")", "{", "// HOD does not return the domain for documents yet, but it does return the index", "final", "String", "index", "=", "document", ".", "getIndex", "(", ")", ";", "String", "domain", "=", "null", ";", "// It's most likely that the returned documents will be in one of the indexes we are querying (hopefully the", "// names are unique between the domains...)", "for", "(", "final", "ResourceName", "indexIdentifier", ":", "indexIdentifiers", ")", "{", "if", "(", "index", ".", "equals", "(", "indexIdentifier", ".", "getName", "(", ")", ")", ")", "{", "domain", "=", "indexIdentifier", ".", "getDomain", "(", ")", ";", "break", ";", "}", "}", "if", "(", "domain", "==", "null", ")", "{", "// If not, it might be a public index", "domain", "=", "PUBLIC_INDEX_NAMES", ".", "contains", "(", "index", ")", "?", "ResourceName", ".", "PUBLIC_INDEXES_DOMAIN", ":", "getDomain", "(", ")", ";", "}", "return", "document", ".", "toBuilder", "(", ")", ".", "domain", "(", "domain", ")", ".", "build", "(", ")", ";", "}" ]

[ "Add", "a", "domain", "to", "a", "FindDocument", "given", "the", "collection", "of", "indexes", "which", "were", "queried", "against", "to", "return", "it", "from", "HOD" ]

[ "List", "<", "String", ">", "splitEffects", "(", "final", "String", "s", ")", "{", "return", "Splitter", ".", "on", "(", "\"&\"", ")", ".", "omitEmptyStrings", "(", ")", ".", "splitToList", "(", "s", ")", ";", "}" ]

[ "Split", "the", "specified", "string", "into", "a", "list", "of", "effects", "." ]

[ "List", "<", "VariantAnnotationMessage", ">", "splitMessages", "(", "final", "String", "s", ",", "final", "ConversionStringency", "stringency", ",", "final", "Logger", "logger", ")", "throws", "ConversionException", "{", "return", "Splitter", ".", "on", "(", "\"&\"", ")", ".", "omitEmptyStrings", "(", ")", ".", "splitToList", "(", "s", ")", ".", "stream", "(", ")", ".", "map", "(", "m", "->", "variantAnnotationMessageConverter", ".", "convert", "(", "m", ",", "stringency", ",", "logger", ")", ")", ".", "collect", "(", "toList", "(", ")", ")", ";", "}" ]

[ "Split", "the", "specified", "string", "into", "a", "list", "of", "variant", "annotation", "messages", "." ]

[ "static", "Integer", "emptyToNullInteger", "(", "final", "String", "s", ")", "{", "return", "\"\"", ".", "equals", "(", "s", ")", "?", "null", ":", "Integer", ".", "parseInt", "(", "s", ")", ";", "}" ]

[ "Parse", "the", "specified", "string", "into", "an", "integer", "returning", "null", "if", "the", "string", "is", "empty", "." ]

[ "static", "Integer", "numerator", "(", "final", "String", "s", ")", "{", "if", "(", "\"\"", ".", "equals", "(", "s", ")", ")", "{", "return", "null", ";", "}", "String", "[", "]", "tokens", "=", "s", ".", "split", "(", "\"/\"", ")", ";", "return", "emptyToNullInteger", "(", "tokens", "[", "0", "]", ")", ";", "}" ]

[ "Parse", "the", "specified", "string", "as", "a", "fraction", "and", "return", "the", "numerator", "if", "any", "." ]

[ "static", "Integer", "denominator", "(", "final", "String", "s", ")", "{", "if", "(", "\"\"", ".", "equals", "(", "s", ")", ")", "{", "return", "null", ";", "}", "String", "[", "]", "tokens", "=", "s", ".", "split", "(", "\"/\"", ")", ";", "return", "(", "tokens", ".", "length", "<", "2", ")", "?", "null", ":", "emptyToNullInteger", "(", "tokens", "[", "1", "]", ")", ";", "}" ]

[ "Parse", "the", "specified", "string", "as", "a", "fraction", "and", "return", "the", "denominator", "if", "any", "." ]

[ "@", "Nonnull", "public", "static", "<", "T", ">", "JPAExecutionResult", "<", "T", ">", "createSuccess", "(", "@", "Nullable", "final", "T", "aObj", ")", "{", "return", "new", "JPAExecutionResult", "<>", "(", "ESuccess", ".", "SUCCESS", ",", "aObj", ",", "null", ")", ";", "}" ]

[ "Create", "a", "new", "success", "object", "." ]

[ "@", "Nonnull", "public", "static", "<", "T", ">", "JPAExecutionResult", "<", "T", ">", "createFailure", "(", "@", "Nullable", "final", "Exception", "ex", ")", "{", "return", "new", "JPAExecutionResult", "<>", "(", "ESuccess", ".", "FAILURE", ",", "null", ",", "ex", ")", ";", "}" ]

[ "Create", "a", "new", "failure", "object", "." ]

[ "public", "static", "void", "doOnMainThread", "(", "final", "OnMainThreadJob", "onMainThreadJob", ")", "{", "uiHandler", ".", "post", "(", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "onMainThreadJob", ".", "doInUIThread", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Executes", "the", "provided", "code", "immediately", "on", "the", "UI", "Thread" ]

[ "public", "static", "void", "doInBackground", "(", "final", "OnBackgroundJob", "onBackgroundJob", ")", "{", "new", "Thread", "(", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "onBackgroundJob", ".", "doOnBackground", "(", ")", ";", "}", "}", ")", ".", "start", "(", ")", ";", "}" ]

[ "Executes", "the", "provided", "code", "immediately", "on", "a", "background", "thread" ]

[ "public", "static", "FutureTask", "doInBackground", "(", "final", "OnBackgroundJob", "onBackgroundJob", ",", "ExecutorService", "executor", ")", "{", "FutureTask", "task", "=", "(", "FutureTask", ")", "executor", ".", "submit", "(", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "onBackgroundJob", ".", "doOnBackground", "(", ")", ";", "}", "}", ")", ";", "return", "task", ";", "}" ]

[ "Executes", "the", "provided", "code", "immediately", "on", "a", "background", "thread", "that", "will", "be", "submitted", "to", "the", "provided", "ExecutorService" ]

[ "public", "void", "start", "(", ")", "{", "if", "(", "actionInBackground", "!=", "null", ")", "{", "Runnable", "jobToRun", "=", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "result", "=", "(", "JobResult", ")", "actionInBackground", ".", "doAsync", "(", ")", ";", "onResult", "(", ")", ";", "}", "}", ";", "if", "(", "getExecutorService", "(", ")", "!=", "null", ")", "{", "asyncFutureTask", "=", "(", "FutureTask", ")", "getExecutorService", "(", ")", ".", "submit", "(", "jobToRun", ")", ";", "}", "else", "{", "asyncThread", "=", "new", "Thread", "(", "jobToRun", ")", ";", "asyncThread", ".", "start", "(", ")", ";", "}", "}", "}" ]

[ "Begins", "the", "background", "execution", "providing", "a", "result", "similar", "to", "an", "AsyncTask", ".", "It", "will", "execute", "it", "on", "a", "new", "Thread", "or", "using", "the", "provided", "ExecutorService" ]

[ "public", "void", "cancel", "(", ")", "{", "if", "(", "actionInBackground", "!=", "null", ")", "{", "if", "(", "executorService", "!=", "null", ")", "{", "asyncFutureTask", ".", "cancel", "(", "true", ")", ";", "}", "else", "{", "asyncThread", ".", "interrupt", "(", ")", ";", "}", "}", "}" ]

[ "Cancels", "the", "AsyncJob", "interrupting", "the", "inner", "thread", "." ]

[ "public", "static", "String", "replacePathParam", "(", "final", "String", "url", ",", "final", "String", "param", ",", "final", "String", "value", ")", "throws", "EncoderException", "{", "final", "String", "pathParam", "=", "param", ".", "startsWith", "(", "\"{\"", ")", "?", "param", ":", "\"{\"", "+", "param", "+", "\"}\"", ";", "final", "String", "encodedValue", "=", "encode", "(", "value", ")", ";", "return", "StringUtils", ".", "replace", "(", "url", ",", "pathParam", ",", "encodedValue", ")", ";", "}" ]

[ "Replaces", "path", "param", "in", "uri", "to", "a", "valid", "encoded", "value" ]

[ "public", "static", "List", "<", "String", ">", "extractPathParams", "(", "final", "String", "url", ")", "{", "final", "List", "<", "String", ">", "pathParams", "=", "new", "ArrayList", "<>", "(", ")", ";", "int", "index", "=", "url", ".", "indexOf", "(", "'", "'", ")", ";", "while", "(", "index", ">=", "0", ")", "{", "final", "int", "endIndex", "=", "url", ".", "indexOf", "(", "'", "'", ",", "index", ")", ";", "final", "String", "pathParam", "=", "url", ".", "substring", "(", "index", "+", "1", ",", "endIndex", ")", ";", "pathParams", ".", "add", "(", "pathParam", ")", ";", "index", "=", "url", ".", "indexOf", "(", "'", "'", ",", "endIndex", ")", ";", "}", "return", "pathParams", ";", "}" ]

[ "Extracts", "all", "path", "params", "in", "url" ]

[ "private", "void", "prepareRequestBody", "(", ")", "throws", "IOException", "{", "if", "(", "bodyByteArray", "!=", "null", ")", "{", "setByteArrayBody", "(", ")", ";", "}", "else", "if", "(", "bodyString", "!=", "null", ")", "{", "setStringBody", "(", ")", ";", "}", "else", "if", "(", "bodyObject", "!=", "null", ")", "{", "setTypedBody", "(", ")", ";", "}", "}" ]

[ "Prepares", "the", "request", "body", "-", "setting", "the", "body", "charset", "and", "content", "length", "by", "body", "type" ]

[ "@", "Override", "public", "Observable", "<", "String", ">", "helloUserStream", "(", "final", "String", "name", ",", "final", "int", "repeats", ")", "{", "return", "interval", "(", "100", ",", "TimeUnit", ".", "MILLISECONDS", ")", ".", "map", "(", "i", "->", "\"Hello, \"", "+", "name", "+", "\"! (#\"", "+", "i", "+", "\")\"", ")", ".", "take", "(", "repeats", ")", ";", "}" ]

[ "Endpoint", "which", "receives", "username", "and", "repeats", "number", "and", "returns", "stream", "of", "messages", "limited", "by", "the", "repeat", "number", "size" ]

[ "public", "static", "<", "T", ",", "R", ">", "Observable", "<", "List", "<", "R", ">", ">", "batchToStream", "(", "final", "List", "<", "T", ">", "elements", ",", "final", "int", "batchSize", ",", "final", "FutureSuccessHandler", "<", "T", ",", "R", ">", "producer", ")", "{", "return", "Observable", ".", "create", "(", "subscriber", "->", "batchToStream", "(", "elements", ",", "batchSize", ",", "0", ",", "subscriber", ",", "producer", ")", ")", ";", "}" ]

[ "Execute", "the", "producer", "on", "each", "element", "in", "the", "list", "in", "batches", "and", "return", "a", "stream", "of", "batch", "results", ".", "Every", "batch", "is", "executed", "in", "parallel", "and", "the", "next", "batch", "begins", "only", "after", "the", "previous", "one", "ended", ".", "The", "result", "of", "each", "batch", "is", "the", "next", "element", "in", "the", "stream", ".", "An", "error", "in", "one", "of", "the", "futures", "produced", "by", "the", "producer", "will", "end", "the", "stream", "with", "the", "error" ]

[ "public", "static", "<", "T", ">", "ComposableFuture", "<", "T", ">", "submit", "(", "final", "Callable", "<", "T", ">", "task", ")", "{", "return", "submit", "(", "false", ",", "task", ")", ";", "}" ]

[ "sends", "a", "callable", "task", "to", "the", "default", "thread", "pool", "and", "returns", "a", "ComposableFuture", "that", "represent", "the", "result", "." ]

[ "public", "static", "<", "T", ">", "ComposableFuture", "<", "T", ">", "buildLazy", "(", "final", "Producer", "<", "T", ">", "producer", ")", "{", "return", "LazyComposableFuture", ".", "build", "(", "producer", ")", ";", "}" ]

[ "builds", "a", "lazy", "future", "from", "a", "producer", ".", "the", "producer", "itself", "is", "cached", "and", "used", "afresh", "on", "every", "consumption", "." ]

[ "public", "static", "<", "T", ">", "ComposableFuture", "<", "T", ">", "withTimeout", "(", "final", "ComposableFuture", "<", "T", ">", "future", ",", "final", "long", "duration", ",", "final", "TimeUnit", "unit", ")", "{", "return", "future", ".", "withTimeout", "(", "SchedulerServiceHolder", ".", "INSTANCE", ",", "duration", ",", "unit", ")", ";", "}" ]

[ "adds", "a", "time", "cap", "to", "the", "provided", "future", ".", "if", "response", "do", "not", "arrive", "after", "the", "specified", "time", "a", "TimeoutException", "is", "returned", "from", "the", "returned", "future", "." ]

[ "@", "Deprecated", "public", "static", "<", "T", ">", "ComposableFuture", "<", "T", ">", "retry", "(", "final", "int", "retries", ",", "final", "long", "duration", ",", "final", "TimeUnit", "unit", ",", "final", "FutureAction", "<", "T", ">", "action", ")", "{", "return", "action", ".", "execute", "(", ")", ".", "withTimeout", "(", "duration", ",", "unit", ")", ".", "recoverWith", "(", "error", "->", "{", "if", "(", "retries", "<", "1", ")", "{", "return", "ComposableFutures", ".", "fromError", "(", "error", ")", ";", "}", "return", "retry", "(", "retries", "-", "1", ",", "action", ")", ";", "}", ")", ";", "}" ]

[ "reties", "an", "eager", "future", "on", "failure", "retries", "times", ".", "each", "try", "is", "time", "capped", "with", "the", "specified", "time", "limit", "." ]

[ "public", "static", "<", "T", ">", "ComposableFuture", "<", "T", ">", "doubleDispatch", "(", "final", "long", "duration", ",", "final", "TimeUnit", "unit", ",", "final", "FutureAction", "<", "T", ">", "action", ")", "{", "return", "EagerComposableFuture", ".", "doubleDispatch", "(", "action", ",", "duration", ",", "unit", ",", "getScheduler", "(", ")", ")", ";", "}" ]

[ "creates", "a", "future", "that", "fires", "the", "first", "future", "immediately", "and", "a", "second", "one", "after", "a", "specified", "time", "period", "if", "result", "hasn", "t", "arrived", "yet", ".", "should", "be", "used", "with", "eager", "futures", "." ]

[ "public", "static", "<", "T", ">", "Observable", "<", "T", ">", "toColdObservable", "(", "final", "List", "<", "ComposableFuture", "<", "T", ">", ">", "futures", ",", "final", "boolean", "failOnError", ")", "{", "return", "Observable", ".", "create", "(", "subscriber", "->", "{", "final", "AtomicInteger", "counter", "=", "new", "AtomicInteger", "(", "futures", ".", "size", "(", ")", ")", ";", "final", "AtomicBoolean", "errorTrigger", "=", "new", "AtomicBoolean", "(", "false", ")", ";", "for", "(", "final", "ComposableFuture", "<", "T", ">", "future", ":", "futures", ")", "{", "future", ".", "consume", "(", "provideObserverResult", "(", "subscriber", ",", "counter", ",", "errorTrigger", ",", "failOnError", ")", ")", ";", "}", "}", ")", ";", "}" ]

[ "translate", "a", "list", "of", "lazy", "futures", "to", "a", "cold", "Observable", "stream" ]

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

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

[ "public", "static", "<", "T", ">", "Observable", "<", "T", ">", "toHotObservable", "(", "final", "List", "<", "ComposableFuture", "<", "T", ">", ">", "futures", ",", "final", "boolean", "failOnError", ")", "{", "final", "ReplaySubject", "<", "T", ">", "subject", "=", "ReplaySubject", ".", "create", "(", "futures", ".", "size", "(", ")", ")", ";", "final", "AtomicInteger", "counter", "=", "new", "AtomicInteger", "(", "futures", ".", "size", "(", ")", ")", ";", "final", "AtomicBoolean", "errorTrigger", "=", "new", "AtomicBoolean", "(", "false", ")", ";", "for", "(", "final", "ComposableFuture", "<", "T", ">", "future", ":", "futures", ")", "{", "future", ".", "consume", "(", "provideObserverResult", "(", "subject", ",", "counter", ",", "errorTrigger", ",", "failOnError", ")", ")", ";", "}", "return", "subject", ";", "}" ]

[ "translate", "a", "list", "of", "eager", "futures", "into", "a", "hot", "Observable", "stream", "the", "results", "of", "the", "futures", "will", "be", "stored", "in", "the", "stream", "for", "any", "future", "subscriber", "." ]