Datasets:

---

CM

/

codexglue_code2text_java

like 4

[ "public", "Map", "<", "Integer", ",", "String", ">", "getSignatures", "(", ")", "{", "ensureRunning", "(", ")", ";", "// Make a copy so callers get an immutable snapshot of the current state.", "return", "Collections", ".", "unmodifiableMap", "(", "new", "HashMap", "<", "Integer", ",", "String", ">", "(", "signatures", ")", ")", ";", "}" ]

[ "Get", "the", "signatures", "that", "have", "been", "computed", "for", "all", "tracks", "currently", "loaded", "in", "any", "player", "for", "which", "we", "have", "been", "able", "to", "obtain", "all", "necessary", "metadata", "." ]

[ "private", "void", "checkExistingTracks", "(", ")", "{", "SwingUtilities", ".", "invokeLater", "(", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "for", "(", "Map", ".", "Entry", "<", "DeckReference", ",", "TrackMetadata", ">", "entry", ":", "MetadataFinder", ".", "getInstance", "(", ")", ".", "getLoadedTracks", "(", ")", ".", "entrySet", "(", ")", ")", "{", "if", "(", "entry", ".", "getKey", "(", ")", ".", "hotCue", "==", "0", ")", "{", "// The track is currently loaded in a main player deck", "checkIfSignatureReady", "(", "entry", ".", "getKey", "(", ")", ".", "player", ")", ";", "}", "}", "}", "}", ")", ";", "}" ]

[ "Send", "ourselves", "updates", "about", "any", "tracks", "that", "were", "loaded", "before", "we", "started", "since", "we", "missed", "them", "." ]

[ "private", "void", "digestInteger", "(", "MessageDigest", "digest", ",", "int", "value", ")", "{", "byte", "[", "]", "valueBytes", "=", "new", "byte", "[", "4", "]", ";", "Util", ".", "numberToBytes", "(", "value", ",", "valueBytes", ",", "0", ",", "4", ")", ";", "digest", ".", "update", "(", "valueBytes", ")", ";", "}" ]

[ "Helper", "method", "to", "add", "a", "Java", "integer", "value", "to", "a", "message", "digest", "." ]

[ "public", "String", "computeTrackSignature", "(", "final", "String", "title", ",", "final", "SearchableItem", "artist", ",", "final", "int", "duration", ",", "final", "WaveformDetail", "waveformDetail", ",", "final", "BeatGrid", "beatGrid", ")", "{", "final", "String", "safeTitle", "=", "(", "title", "==", "null", ")", "?", "\"\"", ":", "title", ";", "final", "String", "artistName", "=", "(", "artist", "==", "null", ")", "?", "\"[no artist]\"", ":", "artist", ".", "label", ";", "try", "{", "// Compute the SHA-1 hash of our fields", "MessageDigest", "digest", "=", "MessageDigest", ".", "getInstance", "(", "\"SHA1\"", ")", ";", "digest", ".", "update", "(", "safeTitle", ".", "getBytes", "(", "\"UTF-8\"", ")", ")", ";", "digest", ".", "update", "(", "(", "byte", ")", "0", ")", ";", "digest", ".", "update", "(", "artistName", ".", "getBytes", "(", "\"UTF-8\"", ")", ")", ";", "digest", ".", "update", "(", "(", "byte", ")", "0", ")", ";", "digestInteger", "(", "digest", ",", "duration", ")", ";", "digest", ".", "update", "(", "waveformDetail", ".", "getData", "(", ")", ")", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<=", "beatGrid", ".", "beatCount", ";", "i", "++", ")", "{", "digestInteger", "(", "digest", ",", "beatGrid", ".", "getBeatWithinBar", "(", "i", ")", ")", ";", "digestInteger", "(", "digest", ",", "(", "int", ")", "beatGrid", ".", "getTimeWithinTrack", "(", "i", ")", ")", ";", "}", "byte", "[", "]", "result", "=", "digest", ".", "digest", "(", ")", ";", "// Create a hex string representation of the hash", "StringBuilder", "hex", "=", "new", "StringBuilder", "(", "result", ".", "length", "*", "2", ")", ";", "for", "(", "byte", "aResult", ":", "result", ")", "{", "hex", ".", "append", "(", "Integer", ".", "toString", "(", "(", "aResult", "&", "0xff", ")", "+", "0x100", ",", "16", ")", ".", "substring", "(", "1", ")", ")", ";", "}", "return", "hex", ".", "toString", "(", ")", ";", "}", "catch", "(", "NullPointerException", "e", ")", "{", "logger", ".", "info", "(", "\"Returning null track signature because an input element was null.\"", ",", "e", ")", ";", "}", "catch", "(", "NoSuchAlgorithmException", "e", ")", "{", "logger", ".", "error", "(", "\"Unable to obtain SHA-1 MessageDigest instance for computing track signatures.\"", ",", "e", ")", ";", "}", "catch", "(", "UnsupportedEncodingException", "e", ")", "{", "logger", ".", "error", "(", "\"Unable to work with UTF-8 string encoding for computing track signatures.\"", ",", "e", ")", ";", "}", "return", "null", ";", "// We were unable to compute a signature", "}" ]

[ "Calculate", "the", "signature", "by", "which", "we", "can", "reliably", "recognize", "a", "loaded", "track", "." ]

[ "private", "void", "handleUpdate", "(", "final", "int", "player", ")", "{", "final", "TrackMetadata", "metadata", "=", "MetadataFinder", ".", "getInstance", "(", ")", ".", "getLatestMetadataFor", "(", "player", ")", ";", "final", "WaveformDetail", "waveformDetail", "=", "WaveformFinder", ".", "getInstance", "(", ")", ".", "getLatestDetailFor", "(", "player", ")", ";", "final", "BeatGrid", "beatGrid", "=", "BeatGridFinder", ".", "getInstance", "(", ")", ".", "getLatestBeatGridFor", "(", "player", ")", ";", "if", "(", "metadata", "!=", "null", "&&", "waveformDetail", "!=", "null", "&&", "beatGrid", "!=", "null", ")", "{", "final", "String", "signature", "=", "computeTrackSignature", "(", "metadata", ".", "getTitle", "(", ")", ",", "metadata", ".", "getArtist", "(", ")", ",", "metadata", ".", "getDuration", "(", ")", ",", "waveformDetail", ",", "beatGrid", ")", ";", "if", "(", "signature", "!=", "null", ")", "{", "signatures", ".", "put", "(", "player", ",", "signature", ")", ";", "deliverSignatureUpdate", "(", "player", ",", "signature", ")", ";", "}", "}", "}" ]

[ "We", "have", "reason", "to", "believe", "we", "might", "have", "enough", "information", "to", "calculate", "a", "signature", "for", "the", "track", "loaded", "on", "a", "player", ".", "Verify", "that", "and", "if", "so", "perform", "the", "computation", "and", "record", "and", "report", "the", "new", "signature", "." ]

[ "public", "synchronized", "void", "stop", "(", ")", "{", "if", "(", "isRunning", "(", ")", ")", "{", "MetadataFinder", ".", "getInstance", "(", ")", ".", "removeTrackMetadataListener", "(", "metadataListener", ")", ";", "WaveformFinder", ".", "getInstance", "(", ")", ".", "removeWaveformListener", "(", "waveformListener", ")", ";", "BeatGridFinder", ".", "getInstance", "(", ")", ".", "removeBeatGridListener", "(", "beatGridListener", ")", ";", "running", ".", "set", "(", "false", ")", ";", "pendingUpdates", ".", "clear", "(", ")", ";", "queueHandler", ".", "interrupt", "(", ")", ";", "queueHandler", "=", "null", ";", "// Report the loss of our signatures, on the proper thread, outside our lock", "final", "Set", "<", "Integer", ">", "dyingSignatures", "=", "new", "HashSet", "<", "Integer", ">", "(", "signatures", ".", "keySet", "(", ")", ")", ";", "signatures", ".", "clear", "(", ")", ";", "SwingUtilities", ".", "invokeLater", "(", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "for", "(", "Integer", "player", ":", "dyingSignatures", ")", "{", "deliverSignatureUpdate", "(", "player", ",", "null", ")", ";", "}", "}", "}", ")", ";", "}", "deliverLifecycleAnnouncement", "(", "logger", ",", "false", ")", ";", "}" ]

[ "Stop", "finding", "signatures", "for", "all", "active", "players", "." ]

[ "private", "void", "expireDevices", "(", ")", "{", "long", "now", "=", "System", ".", "currentTimeMillis", "(", ")", ";", "// Make a copy so we don't have to worry about concurrent modification.", "Map", "<", "InetAddress", ",", "DeviceAnnouncement", ">", "copy", "=", "new", "HashMap", "<", "InetAddress", ",", "DeviceAnnouncement", ">", "(", "devices", ")", ";", "for", "(", "Map", ".", "Entry", "<", "InetAddress", ",", "DeviceAnnouncement", ">", "entry", ":", "copy", ".", "entrySet", "(", ")", ")", "{", "if", "(", "now", "-", "entry", ".", "getValue", "(", ")", ".", "getTimestamp", "(", ")", ">", "MAXIMUM_AGE", ")", "{", "devices", ".", "remove", "(", "entry", ".", "getKey", "(", ")", ")", ";", "deliverLostAnnouncement", "(", "entry", ".", "getValue", "(", ")", ")", ";", "}", "}", "if", "(", "devices", ".", "isEmpty", "(", ")", ")", "{", "firstDeviceTime", ".", "set", "(", "0", ")", ";", "// We have lost contact with the Pro DJ Link network, so start over with next device.", "}", "}" ]

[ "Remove", "any", "device", "announcements", "that", "are", "so", "old", "that", "the", "device", "seems", "to", "have", "gone", "away", "." ]

[ "private", "void", "updateDevices", "(", "DeviceAnnouncement", "announcement", ")", "{", "firstDeviceTime", ".", "compareAndSet", "(", "0", ",", "System", ".", "currentTimeMillis", "(", ")", ")", ";", "devices", ".", "put", "(", "announcement", ".", "getAddress", "(", ")", ",", "announcement", ")", ";", "}" ]

[ "Record", "a", "device", "announcement", "in", "the", "devices", "map", "so", "we", "know", "whe", "saw", "it", "." ]

[ "public", "synchronized", "void", "start", "(", ")", "throws", "SocketException", "{", "if", "(", "!", "isRunning", "(", ")", ")", "{", "socket", ".", "set", "(", "new", "DatagramSocket", "(", "ANNOUNCEMENT_PORT", ")", ")", ";", "startTime", ".", "set", "(", "System", ".", "currentTimeMillis", "(", ")", ")", ";", "deliverLifecycleAnnouncement", "(", "logger", ",", "true", ")", ";", "final", "byte", "[", "]", "buffer", "=", "new", "byte", "[", "512", "]", ";", "final", "DatagramPacket", "packet", "=", "new", "DatagramPacket", "(", "buffer", ",", "buffer", ".", "length", ")", ";", "Thread", "receiver", "=", "new", "Thread", "(", "null", ",", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "boolean", "received", ";", "while", "(", "isRunning", "(", ")", ")", "{", "try", "{", "if", "(", "getCurrentDevices", "(", ")", ".", "isEmpty", "(", ")", ")", "{", "socket", ".", "get", "(", ")", ".", "setSoTimeout", "(", "60000", ")", ";", "// We have no devices to check for timeout; block for a whole minute to check for shutdown", "}", "else", "{", "socket", ".", "get", "(", ")", ".", "setSoTimeout", "(", "1000", ")", ";", "// Check every second to see if a device has vanished", "}", "socket", ".", "get", "(", ")", ".", "receive", "(", "packet", ")", ";", "received", "=", "!", "ignoredAddresses", ".", "contains", "(", "packet", ".", "getAddress", "(", ")", ")", ";", "}", "catch", "(", "SocketTimeoutException", "ste", ")", "{", "received", "=", "false", ";", "}", "catch", "(", "IOException", "e", ")", "{", "// Don't log a warning if the exception was due to the socket closing at shutdown.", "if", "(", "isRunning", "(", ")", ")", "{", "// We did not expect to have a problem; log a warning and shut down.", "logger", ".", "warn", "(", "\"Problem reading from DeviceAnnouncement socket, stopping\"", ",", "e", ")", ";", "stop", "(", ")", ";", "}", "received", "=", "false", ";", "}", "try", "{", "if", "(", "received", "&&", "(", "packet", ".", "getLength", "(", ")", "==", "54", ")", ")", "{", "final", "Util", ".", "PacketType", "kind", "=", "Util", ".", "validateHeader", "(", "packet", ",", "ANNOUNCEMENT_PORT", ")", ";", "if", "(", "kind", "==", "Util", ".", "PacketType", ".", "DEVICE_KEEP_ALIVE", ")", "{", "// Looks like the kind of packet we need", "if", "(", "packet", ".", "getLength", "(", ")", "<", "54", ")", "{", "logger", ".", "warn", "(", "\"Ignoring too-short \"", "+", "kind", ".", "name", "+", "\" packet; expected 54 bytes, but only got \"", "+", "packet", ".", "getLength", "(", ")", "+", "\".\"", ")", ";", "}", "else", "{", "if", "(", "packet", ".", "getLength", "(", ")", ">", "54", ")", "{", "logger", ".", "warn", "(", "\"Processing too-long \"", "+", "kind", ".", "name", "+", "\" packet; expected 54 bytes, but got \"", "+", "packet", ".", "getLength", "(", ")", "+", "\".\"", ")", ";", "}", "DeviceAnnouncement", "announcement", "=", "new", "DeviceAnnouncement", "(", "packet", ")", ";", "final", "boolean", "foundNewDevice", "=", "isDeviceNew", "(", "announcement", ")", ";", "updateDevices", "(", "announcement", ")", ";", "if", "(", "foundNewDevice", ")", "{", "deliverFoundAnnouncement", "(", "announcement", ")", ";", "}", "}", "}", "}", "expireDevices", "(", ")", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Problem processing DeviceAnnouncement packet\"", ",", "t", ")", ";", "}", "}", "}", "}", ",", "\"beat-link DeviceFinder receiver\"", ")", ";", "receiver", ".", "setDaemon", "(", "true", ")", ";", "receiver", ".", "start", "(", ")", ";", "}", "}" ]

[ "Start", "listening", "for", "device", "announcements", "and", "keeping", "track", "of", "the", "DJ", "Link", "devices", "visible", "on", "the", "network", ".", "If", "already", "listening", "has", "no", "effect", "." ]

[ "@", "SuppressWarnings", "(", "\"WeakerAccess\"", ")", "public", "synchronized", "void", "stop", "(", ")", "{", "if", "(", "isRunning", "(", ")", ")", "{", "final", "Set", "<", "DeviceAnnouncement", ">", "lastDevices", "=", "getCurrentDevices", "(", ")", ";", "socket", ".", "get", "(", ")", ".", "close", "(", ")", ";", "socket", ".", "set", "(", "null", ")", ";", "devices", ".", "clear", "(", ")", ";", "firstDeviceTime", ".", "set", "(", "0", ")", ";", "// Report the loss of all our devices, on the proper thread, outside our lock", "SwingUtilities", ".", "invokeLater", "(", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "for", "(", "DeviceAnnouncement", "announcement", ":", "lastDevices", ")", "{", "deliverLostAnnouncement", "(", "announcement", ")", ";", "}", "}", "}", ")", ";", "deliverLifecycleAnnouncement", "(", "logger", ",", "false", ")", ";", "}", "}" ]

[ "Stop", "listening", "for", "device", "announcements", ".", "Also", "discard", "any", "announcements", "which", "had", "been", "received", "and", "notify", "any", "registered", "listeners", "that", "those", "devices", "have", "been", "lost", "." ]

[ "private", "void", "deliverFoundAnnouncement", "(", "final", "DeviceAnnouncement", "announcement", ")", "{", "for", "(", "final", "DeviceAnnouncementListener", "listener", ":", "getDeviceAnnouncementListeners", "(", ")", ")", "{", "SwingUtilities", ".", "invokeLater", "(", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "try", "{", "listener", ".", "deviceFound", "(", "announcement", ")", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Problem delivering device found announcement to listener\"", ",", "t", ")", ";", "}", "}", "}", ")", ";", "}", "}" ]

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

[ "private", "void", "deliverLostAnnouncement", "(", "final", "DeviceAnnouncement", "announcement", ")", "{", "for", "(", "final", "DeviceAnnouncementListener", "listener", ":", "getDeviceAnnouncementListeners", "(", ")", ")", "{", "SwingUtilities", ".", "invokeLater", "(", "new", "Runnable", "(", ")", "{", "@", "Override", "public", "void", "run", "(", ")", "{", "try", "{", "listener", ".", "deviceLost", "(", "announcement", ")", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Problem delivering device lost announcement to listener\"", ",", "t", ")", ";", "}", "}", "}", ")", ";", "}", "}" ]

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

[ "private", "void", "performSetupExchange", "(", ")", "throws", "IOException", "{", "Message", "setupRequest", "=", "new", "Message", "(", "0xfffffffe", "L", ",", "Message", ".", "KnownType", ".", "SETUP_REQ", ",", "new", "NumberField", "(", "posingAsPlayer", ",", "4", ")", ")", ";", "sendMessage", "(", "setupRequest", ")", ";", "Message", "response", "=", "Message", ".", "read", "(", "is", ")", ";", "if", "(", "response", ".", "knownType", "!=", "Message", ".", "KnownType", ".", "MENU_AVAILABLE", ")", "{", "throw", "new", "IOException", "(", "\"Did not receive message type 0x4000 in response to setup message, got: \"", "+", "response", ")", ";", "}", "if", "(", "response", ".", "arguments", ".", "size", "(", ")", "!=", "2", ")", "{", "throw", "new", "IOException", "(", "\"Did not receive two arguments in response to setup message, got: \"", "+", "response", ")", ";", "}", "final", "Field", "player", "=", "response", ".", "arguments", ".", "get", "(", "1", ")", ";", "if", "(", "!", "(", "player", "instanceof", "NumberField", ")", ")", "{", "throw", "new", "IOException", "(", "\"Second argument in response to setup message was not a number: \"", "+", "response", ")", ";", "}", "if", "(", "(", "(", "NumberField", ")", "player", ")", ".", "getValue", "(", ")", "!=", "targetPlayer", ")", "{", "throw", "new", "IOException", "(", "\"Expected to connect to player \"", "+", "targetPlayer", "+", "\", but welcome response identified itself as player \"", "+", "(", "(", "NumberField", ")", "player", ")", ".", "getValue", "(", ")", ")", ";", "}", "}" ]

[ "Exchanges", "the", "initial", "fully", "-", "formed", "messages", "which", "establishes", "the", "transaction", "context", "for", "queries", "to", "the", "dbserver", "." ]

[ "private", "void", "performTeardownExchange", "(", ")", "throws", "IOException", "{", "Message", "teardownRequest", "=", "new", "Message", "(", "0xfffffffe", "L", ",", "Message", ".", "KnownType", ".", "TEARDOWN_REQ", ")", ";", "sendMessage", "(", "teardownRequest", ")", ";", "// At this point, the server closes the connection from its end, so we can’t read any more.", "}" ]

[ "Exchanges", "the", "final", "messages", "which", "politely", "report", "our", "intention", "to", "disconnect", "from", "the", "dbserver", "." ]

[ "void", "close", "(", ")", "{", "try", "{", "performTeardownExchange", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "logger", ".", "warn", "(", "\"Problem reporting our intention to close the dbserver connection\"", ",", "e", ")", ";", "}", "try", "{", "channel", ".", "close", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "logger", ".", "warn", "(", "\"Problem closing dbserver client output channel\"", ",", "e", ")", ";", "}", "try", "{", "os", ".", "close", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "logger", ".", "warn", "(", "\"Problem closing dbserver client output stream\"", ",", "e", ")", ";", "}", "try", "{", "is", ".", "close", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "logger", ".", "warn", "(", "\"Problem closing dbserver client input stream\"", ",", "e", ")", ";", "}", "try", "{", "socket", ".", "close", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "logger", ".", "warn", "(", "\"Problem closing dbserver client socket\"", ",", "e", ")", ";", "}", "}" ]

[ "Closes", "the", "connection", "to", "the", "dbserver", ".", "This", "instance", "can", "no", "longer", "be", "used", "after", "this", "action", "." ]

[ "@", "SuppressWarnings", "(", "\"SameParameterValue\"", ")", "private", "void", "sendField", "(", "Field", "field", ")", "throws", "IOException", "{", "if", "(", "isConnected", "(", ")", ")", "{", "try", "{", "field", ".", "write", "(", "channel", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "logger", ".", "warn", "(", "\"Problem trying to write field to dbserver, closing connection\"", ",", "e", ")", ";", "close", "(", ")", ";", "throw", "e", ";", "}", "return", ";", "}", "throw", "new", "IOException", "(", "\"sendField() called after dbserver connection was closed\"", ")", ";", "}" ]

[ "Attempt", "to", "send", "the", "specified", "field", "to", "the", "dbserver", ".", "This", "low", "-", "level", "function", "is", "available", "only", "to", "the", "package", "itself", "for", "use", "in", "setting", "up", "the", "connection", ".", "It", "was", "previously", "also", "used", "for", "sending", "parts", "of", "larger", "-", "scale", "messages", "but", "because", "that", "sometimes", "led", "to", "them", "being", "fragmented", "into", "multiple", "network", "packets", "and", "Windows", "rekordbox", "cannot", "handle", "that", "full", "message", "sending", "no", "longer", "uses", "this", "method", "." ]

[ "private", "void", "sendMessage", "(", "Message", "message", ")", "throws", "IOException", "{", "logger", ".", "debug", "(", "\"Sending> {}\"", ",", "message", ")", ";", "int", "totalSize", "=", "0", ";", "for", "(", "Field", "field", ":", "message", ".", "fields", ")", "{", "totalSize", "+=", "field", ".", "getBytes", "(", ")", ".", "remaining", "(", ")", ";", "}", "ByteBuffer", "combined", "=", "ByteBuffer", ".", "allocate", "(", "totalSize", ")", ";", "for", "(", "Field", "field", ":", "message", ".", "fields", ")", "{", "logger", ".", "debug", "(", "\"..sending> {}\"", ",", "field", ")", ";", "combined", ".", "put", "(", "field", ".", "getBytes", "(", ")", ")", ";", "}", "combined", ".", "flip", "(", ")", ";", "Util", ".", "writeFully", "(", "combined", ",", "channel", ")", ";", "}" ]

[ "Sends", "a", "message", "to", "the", "dbserver", "first", "assembling", "it", "into", "a", "single", "byte", "buffer", "so", "that", "it", "can", "be", "sent", "as", "a", "single", "packet", "." ]

[ "public", "synchronized", "Message", "simpleRequest", "(", "Message", ".", "KnownType", "requestType", ",", "Message", ".", "KnownType", "responseType", ",", "Field", "...", "arguments", ")", "throws", "IOException", "{", "final", "NumberField", "transaction", "=", "assignTransactionNumber", "(", ")", ";", "final", "Message", "request", "=", "new", "Message", "(", "transaction", ",", "new", "NumberField", "(", "requestType", ".", "protocolValue", ",", "2", ")", ",", "arguments", ")", ";", "sendMessage", "(", "request", ")", ";", "final", "Message", "response", "=", "Message", ".", "read", "(", "is", ")", ";", "if", "(", "response", ".", "transaction", ".", "getValue", "(", ")", "!=", "transaction", ".", "getValue", "(", ")", ")", "{", "throw", "new", "IOException", "(", "\"Received response with wrong transaction ID. Expected: \"", "+", "transaction", ".", "getValue", "(", ")", "+", "\", got: \"", "+", "response", ")", ";", "}", "if", "(", "responseType", "!=", "null", "&&", "response", ".", "knownType", "!=", "responseType", ")", "{", "throw", "new", "IOException", "(", "\"Received response with wrong type. Expected: \"", "+", "responseType", "+", "\", got: \"", "+", "response", ")", ";", "}", "return", "response", ";", "}" ]

[ "Send", "a", "request", "that", "expects", "a", "single", "message", "as", "its", "response", "then", "read", "and", "return", "that", "response", "." ]

[ "public", "synchronized", "Message", "menuRequestTyped", "(", "Message", ".", "KnownType", "requestType", ",", "Message", ".", "MenuIdentifier", "targetMenu", ",", "CdjStatus", ".", "TrackSourceSlot", "slot", ",", "CdjStatus", ".", "TrackType", "trackType", ",", "Field", "...", "arguments", ")", "throws", "IOException", "{", "if", "(", "!", "menuLock", ".", "isHeldByCurrentThread", "(", ")", ")", "{", "throw", "new", "IllegalStateException", "(", "\"renderMenuItems() cannot be called without first successfully calling tryLockingForMenuOperation()\"", ")", ";", "}", "Field", "[", "]", "combinedArguments", "=", "new", "Field", "[", "arguments", ".", "length", "+", "1", "]", ";", "combinedArguments", "[", "0", "]", "=", "buildRMST", "(", "targetMenu", ",", "slot", ",", "trackType", ")", ";", "System", ".", "arraycopy", "(", "arguments", ",", "0", ",", "combinedArguments", ",", "1", ",", "arguments", ".", "length", ")", ";", "final", "Message", "response", "=", "simpleRequest", "(", "requestType", ",", "Message", ".", "KnownType", ".", "MENU_AVAILABLE", ",", "combinedArguments", ")", ";", "final", "NumberField", "reportedRequestType", "=", "(", "NumberField", ")", "response", ".", "arguments", ".", "get", "(", "0", ")", ";", "if", "(", "reportedRequestType", ".", "getValue", "(", ")", "!=", "requestType", ".", "protocolValue", ")", "{", "throw", "new", "IOException", "(", "\"Menu request did not return result for same type as request; sent type: \"", "+", "requestType", ".", "protocolValue", "+", "\", received type: \"", "+", "reportedRequestType", ".", "getValue", "(", ")", "+", "\", response: \"", "+", "response", ")", ";", "}", "return", "response", ";", "}" ]

[ "Send", "a", "request", "for", "a", "menu", "that", "we", "will", "retrieve", "items", "from", "in", "subsequent", "requests", "when", "the", "request", "must", "reflect", "the", "actual", "type", "of", "track", "being", "asked", "about", "." ]

[ "@", "SuppressWarnings", "(", "\"WeakerAccess\"", ")", "public", "static", "synchronized", "SlotReference", "getSlotReference", "(", "int", "player", ",", "CdjStatus", ".", "TrackSourceSlot", "slot", ")", "{", "Map", "<", "CdjStatus", ".", "TrackSourceSlot", ",", "SlotReference", ">", "playerMap", "=", "instances", ".", "get", "(", "player", ")", ";", "if", "(", "playerMap", "==", "null", ")", "{", "playerMap", "=", "new", "HashMap", "<", "CdjStatus", ".", "TrackSourceSlot", ",", "SlotReference", ">", "(", ")", ";", "instances", ".", "put", "(", "player", ",", "playerMap", ")", ";", "}", "SlotReference", "result", "=", "playerMap", ".", "get", "(", "slot", ")", ";", "if", "(", "result", "==", "null", ")", "{", "result", "=", "new", "SlotReference", "(", "player", ",", "slot", ")", ";", "playerMap", ".", "put", "(", "slot", ",", "result", ")", ";", "}", "return", "result", ";", "}" ]

[ "Get", "a", "unique", "reference", "to", "a", "media", "slot", "on", "the", "network", "from", "which", "tracks", "can", "be", "loaded", "." ]

[ "@", "SuppressWarnings", "(", "\"WeakerAccess\"", ")", "public", "static", "SlotReference", "getSlotReference", "(", "DataReference", "dataReference", ")", "{", "return", "getSlotReference", "(", "dataReference", ".", "player", ",", "dataReference", ".", "slot", ")", ";", "}" ]

[ "Get", "a", "unique", "reference", "to", "the", "media", "slot", "on", "the", "network", "from", "which", "the", "specified", "data", "was", "loaded", "." ]

[ "@", "Override", "public", "boolean", "isTempoMaster", "(", ")", "{", "DeviceUpdate", "master", "=", "VirtualCdj", ".", "getInstance", "(", ")", ".", "getTempoMaster", "(", ")", ";", "return", "(", "master", "!=", "null", ")", "&&", "master", ".", "getAddress", "(", ")", ".", "equals", "(", "address", ")", ";", "}" ]

[ "Was", "this", "beat", "sent", "by", "the", "current", "tempo", "master?" ]

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

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

[ "private", "String", "mountPath", "(", "CdjStatus", ".", "TrackSourceSlot", "slot", ")", "{", "switch", "(", "slot", ")", "{", "case", "SD_SLOT", ":", "return", "\"/B/\"", ";", "case", "USB_SLOT", ":", "return", "\"/C/\"", ";", "}", "throw", "new", "IllegalArgumentException", "(", "\"Don't know how to NFS mount filesystem for slot \"", "+", "slot", ")", ";", "}" ]

[ "Return", "the", "filesystem", "path", "needed", "to", "mount", "the", "NFS", "filesystem", "associated", "with", "a", "particular", "media", "slot", "." ]

[ "private", "void", "deliverDatabaseUpdate", "(", "SlotReference", "slot", ",", "Database", "database", ",", "boolean", "available", ")", "{", "for", "(", "final", "DatabaseListener", "listener", ":", "getDatabaseListeners", "(", ")", ")", "{", "try", "{", "if", "(", "available", ")", "{", "listener", ".", "databaseMounted", "(", "slot", ",", "database", ")", ";", "}", "else", "{", "listener", ".", "databaseUnmounted", "(", "slot", ",", "database", ")", ";", "}", "}", "catch", "(", "Throwable", "t", ")", "{", "logger", ".", "warn", "(", "\"Problem delivering rekordbox database availability update to listener\"", ",", "t", ")", ";", "}", "}", "}" ]

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

[ "@", "SuppressWarnings", "(", "\"SameParameterValue\"", ")", "private", "void", "delegatingRepaint", "(", "int", "x", ",", "int", "y", ",", "int", "width", ",", "int", "height", ")", "{", "final", "RepaintDelegate", "delegate", "=", "repaintDelegate", ".", "get", "(", ")", ";", "if", "(", "delegate", "!=", "null", ")", "{", "//logger.info(\"Delegating repaint: \" + x + \", \" + y + \", \" + width + \", \" + height);", "delegate", ".", "repaint", "(", "x", ",", "y", ",", "width", ",", "height", ")", ";", "}", "else", "{", "//logger.info(\"Normal repaint: \" + x + \", \" + y + \", \" + width + \", \" + height);", "repaint", "(", "x", ",", "y", ",", "width", ",", "height", ")", ";", "}", "}" ]

[ "Determine", "whether", "we", "should", "use", "the", "normal", "repaint", "process", "or", "delegate", "that", "to", "another", "component", "that", "is", "hosting", "us", "in", "a", "soft", "-", "loaded", "manner", "to", "save", "memory", "." ]

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

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

[ "private", "int", "getMaxHeight", "(", ")", "{", "int", "result", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "segmentCount", ";", "i", "++", ")", "{", "result", "=", "Math", ".", "max", "(", "result", ",", "segmentHeight", "(", "i", ",", "false", ")", ")", ";", "}", "return", "result", ";", "}" ]

[ "Scan", "the", "segments", "to", "find", "the", "largest", "height", "value", "present", "." ]

[ "@", "SuppressWarnings", "(", "\"WeakerAccess\"", ")", "public", "int", "segmentHeight", "(", "final", "int", "segment", ",", "final", "boolean", "front", ")", "{", "final", "ByteBuffer", "bytes", "=", "getData", "(", ")", ";", "if", "(", "isColor", ")", "{", "final", "int", "base", "=", "segment", "*", "6", ";", "final", "int", "frontHeight", "=", "Util", ".", "unsign", "(", "bytes", ".", "get", "(", "base", "+", "5", ")", ")", ";", "if", "(", "front", ")", "{", "return", "frontHeight", ";", "}", "else", "{", "return", "Math", ".", "max", "(", "frontHeight", ",", "Math", ".", "max", "(", "Util", ".", "unsign", "(", "bytes", ".", "get", "(", "base", "+", "3", ")", ")", ",", "Util", ".", "unsign", "(", "bytes", ".", "get", "(", "base", "+", "4", ")", ")", ")", ")", ";", "}", "}", "else", "{", "return", "getData", "(", ")", ".", "get", "(", "segment", "*", "2", ")", "&", "0x1f", ";", "}", "}" ]

[ "Determine", "the", "height", "of", "the", "preview", "given", "an", "index", "into", "it", "." ]

[ "@", "SuppressWarnings", "(", "\"WeakerAccess\"", ")", "public", "Color", "segmentColor", "(", "final", "int", "segment", ",", "final", "boolean", "front", ")", "{", "final", "ByteBuffer", "bytes", "=", "getData", "(", ")", ";", "if", "(", "isColor", ")", "{", "final", "int", "base", "=", "segment", "*", "6", ";", "final", "int", "backHeight", "=", "segmentHeight", "(", "segment", ",", "false", ")", ";", "if", "(", "backHeight", "==", "0", ")", "{", "return", "Color", ".", "BLACK", ";", "}", "final", "int", "maxLevel", "=", "front", "?", "255", ":", "191", ";", "final", "int", "red", "=", "Util", ".", "unsign", "(", "bytes", ".", "get", "(", "base", "+", "3", ")", ")", "*", "maxLevel", "/", "backHeight", ";", "final", "int", "green", "=", "Util", ".", "unsign", "(", "bytes", ".", "get", "(", "base", "+", "4", ")", ")", "*", "maxLevel", "/", "backHeight", ";", "final", "int", "blue", "=", "Util", ".", "unsign", "(", "bytes", ".", "get", "(", "base", "+", "5", ")", ")", "*", "maxLevel", "/", "backHeight", ";", "return", "new", "Color", "(", "red", ",", "green", ",", "blue", ")", ";", "}", "else", "{", "final", "int", "intensity", "=", "getData", "(", ")", ".", "get", "(", "segment", "*", "2", "+", "1", ")", "&", "0x07", ";", "return", "(", "intensity", ">=", "5", ")", "?", "INTENSE_COLOR", ":", "NORMAL_COLOR", ";", "}", "}" ]

[ "Determine", "the", "color", "of", "the", "waveform", "given", "an", "index", "into", "it", "." ]

[ "public", "boolean", "hasChanged", "(", "MediaDetails", "originalMedia", ")", "{", "if", "(", "!", "hashKey", "(", ")", ".", "equals", "(", "originalMedia", ".", "hashKey", "(", ")", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Can't compare media details with different hashKey values\"", ")", ";", "}", "return", "playlistCount", "!=", "originalMedia", ".", "playlistCount", "||", "trackCount", "!=", "originalMedia", ".", "trackCount", ";", "}" ]

[ "Check", "whether", "the", "media", "seems", "to", "have", "changed", "since", "a", "saved", "version", "of", "it", "was", "used", ".", "We", "ignore", "changes", "in", "free", "space", "because", "those", "probably", "just", "reflect", "history", "entries", "being", "added", "." ]

[ "public", "byte", "[", "]", "getValueAsArray", "(", ")", "{", "ByteBuffer", "buffer", "=", "getValue", "(", ")", ";", "byte", "[", "]", "result", "=", "new", "byte", "[", "buffer", ".", "remaining", "(", ")", "]", ";", "buffer", ".", "get", "(", "result", ")", ";", "return", "result", ";", "}" ]

[ "Get", "the", "bytes", "which", "represent", "the", "payload", "of", "this", "field", "without", "the", "leading", "type", "tag", "and", "length", "header", "as", "a", "newly", "-", "allocated", "byte", "array", "." ]

[ "public", "int", "getHotCueCount", "(", ")", "{", "if", "(", "rawMessage", "!=", "null", ")", "{", "return", "(", "int", ")", "(", "(", "NumberField", ")", "rawMessage", ".", "arguments", ".", "get", "(", "5", ")", ")", ".", "getValue", "(", ")", ";", "}", "int", "total", "=", "0", ";", "for", "(", "Entry", "entry", ":", "entries", ")", "{", "if", "(", "entry", ".", "hotCueNumber", ">", "0", ")", "{", "++", "total", ";", "}", "}", "return", "total", ";", "}" ]

[ "Return", "the", "number", "of", "entries", "in", "the", "cue", "list", "that", "represent", "hot", "cues", "." ]

[ "private", "List", "<", "Entry", ">", "sortEntries", "(", "List", "<", "Entry", ">", "loadedEntries", ")", "{", "Collections", ".", "sort", "(", "loadedEntries", ",", "new", "Comparator", "<", "Entry", ">", "(", ")", "{", "@", "Override", "public", "int", "compare", "(", "Entry", "entry1", ",", "Entry", "entry2", ")", "{", "int", "result", "=", "(", "int", ")", "(", "entry1", ".", "cuePosition", "-", "entry2", ".", "cuePosition", ")", ";", "if", "(", "result", "==", "0", ")", "{", "int", "h1", "=", "(", "entry1", ".", "hotCueNumber", "!=", "0", ")", "?", "1", ":", "0", ";", "int", "h2", "=", "(", "entry2", ".", "hotCueNumber", "!=", "0", ")", "?", "1", ":", "0", ";", "result", "=", "h1", "-", "h2", ";", "}", "return", "result", ";", "}", "}", ")", ";", "return", "Collections", ".", "unmodifiableList", "(", "loadedEntries", ")", ";", "}" ]

[ "Sorts", "the", "entries", "into", "the", "order", "we", "want", "to", "present", "them", "in", "which", "is", "by", "position", "with", "hot", "cues", "coming", "after", "ordinary", "memory", "points", "if", "both", "exist", "at", "the", "same", "position", "which", "often", "happens", "." ]

[ "private", "void", "addEntriesFromTag", "(", "List", "<", "Entry", ">", "entries", ",", "RekordboxAnlz", ".", "CueTag", "tag", ")", "{", "for", "(", "RekordboxAnlz", ".", "CueEntry", "cueEntry", ":", "tag", ".", "cues", "(", ")", ")", "{", "// TODO: Need to figure out how to identify deleted entries to ignore.", "if", "(", "cueEntry", ".", "type", "(", ")", "==", "RekordboxAnlz", ".", "CueEntryType", ".", "LOOP", ")", "{", "entries", ".", "add", "(", "new", "Entry", "(", "(", "int", ")", "cueEntry", ".", "hotCue", "(", ")", ",", "Util", ".", "timeToHalfFrame", "(", "cueEntry", ".", "time", "(", ")", ")", ",", "Util", ".", "timeToHalfFrame", "(", "cueEntry", ".", "loopTime", "(", ")", ")", ")", ")", ";", "}", "else", "{", "entries", ".", "add", "(", "new", "Entry", "(", "(", "int", ")", "cueEntry", ".", "hotCue", "(", ")", ",", "Util", ".", "timeToHalfFrame", "(", "cueEntry", ".", "time", "(", ")", ")", ")", ")", ";", "}", "}", "}" ]

[ "Helper", "method", "to", "add", "cue", "list", "entries", "from", "a", "parsed", "ANLZ", "cue", "tag" ]

[ "public", "final", "static", "String", "process", "(", "final", "String", "input", ",", "final", "Configuration", "configuration", ")", "{", "try", "{", "return", "process", "(", "new", "StringReader", "(", "input", ")", ",", "configuration", ")", ";", "}", "catch", "(", "final", "IOException", "e", ")", "{", "// This _can never_ happen", "return", "null", ";", "}", "}" ]

[ "Transforms", "an", "input", "String", "into", "HTML", "using", "the", "given", "Configuration", "." ]

[ "public", "final", "static", "String", "process", "(", "final", "File", "file", ",", "final", "Configuration", "configuration", ")", "throws", "IOException", "{", "final", "FileInputStream", "input", "=", "new", "FileInputStream", "(", "file", ")", ";", "final", "String", "ret", "=", "process", "(", "input", ",", "configuration", ")", ";", "input", ".", "close", "(", ")", ";", "return", "ret", ";", "}" ]

[ "Transforms", "an", "input", "file", "into", "HTML", "using", "the", "given", "Configuration", "." ]

[ "public", "final", "static", "String", "process", "(", "final", "File", "file", ",", "final", "boolean", "safeMode", ")", "throws", "IOException", "{", "return", "process", "(", "file", ",", "Configuration", ".", "builder", "(", ")", ".", "setSafeMode", "(", "safeMode", ")", ".", "build", "(", ")", ")", ";", "}" ]

[ "Transforms", "an", "input", "file", "into", "HTML", "." ]

[ "public", "static", "void", "main", "(", "final", "String", "[", "]", "args", ")", "throws", "IOException", "{", "// This is just a _hack_ ...", "BufferedReader", "reader", "=", "null", ";", "if", "(", "args", ".", "length", "==", "0", ")", "{", "System", ".", "err", ".", "println", "(", "\"No input file specified.\"", ")", ";", "System", ".", "exit", "(", "-", "1", ")", ";", "}", "if", "(", "args", ".", "length", ">", "1", ")", "{", "reader", "=", "new", "BufferedReader", "(", "new", "InputStreamReader", "(", "new", "FileInputStream", "(", "args", "[", "1", "]", ")", ",", "\"UTF-8\"", ")", ")", ";", "String", "line", "=", "reader", ".", "readLine", "(", ")", ";", "while", "(", "line", "!=", "null", "&&", "!", "line", ".", "startsWith", "(", "\"<!-- ###\"", ")", ")", "{", "System", ".", "out", ".", "println", "(", "line", ")", ";", "line", "=", "reader", ".", "readLine", "(", ")", ";", "}", "}", "System", ".", "out", ".", "println", "(", "Processor", ".", "process", "(", "new", "File", "(", "args", "[", "0", "]", ")", ")", ")", ";", "if", "(", "args", ".", "length", ">", "1", "&&", "reader", "!=", "null", ")", "{", "String", "line", "=", "reader", ".", "readLine", "(", ")", ";", "while", "(", "line", "!=", "null", ")", "{", "System", ".", "out", ".", "println", "(", "line", ")", ";", "line", "=", "reader", ".", "readLine", "(", ")", ";", "}", "reader", ".", "close", "(", ")", ";", "}", "}" ]

[ "Static", "main", "." ]

[ "public", "static", "List", "<", "String", ">", "parse", "(", "final", "String", "[", "]", "args", ",", "final", "Object", "...", "objs", ")", "throws", "IOException", "{", "final", "List", "<", "String", ">", "ret", "=", "Colls", ".", "list", "(", ")", ";", "final", "List", "<", "Arg", ">", "allArgs", "=", "Colls", ".", "list", "(", ")", ";", "final", "HashMap", "<", "String", ",", "Arg", ">", "shortArgs", "=", "new", "HashMap", "<", "String", ",", "Arg", ">", "(", ")", ";", "final", "HashMap", "<", "String", ",", "Arg", ">", "longArgs", "=", "new", "HashMap", "<", "String", ",", "Arg", ">", "(", ")", ";", "parseArgs", "(", "objs", ",", "allArgs", ",", "shortArgs", ",", "longArgs", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "args", ".", "length", ";", "i", "++", ")", "{", "final", "String", "s", "=", "args", "[", "i", "]", ";", "final", "Arg", "a", ";", "if", "(", "s", ".", "startsWith", "(", "\"--\"", ")", ")", "{", "a", "=", "longArgs", ".", "get", "(", "s", ".", "substring", "(", "2", ")", ")", ";", "if", "(", "a", "==", "null", ")", "{", "throw", "new", "IOException", "(", "\"Unknown switch: \"", "+", "s", ")", ";", "}", "}", "else", "if", "(", "s", ".", "startsWith", "(", "\"-\"", ")", ")", "{", "a", "=", "shortArgs", ".", "get", "(", "s", ".", "substring", "(", "1", ")", ")", ";", "if", "(", "a", "==", "null", ")", "{", "throw", "new", "IOException", "(", "\"Unknown switch: \"", "+", "s", ")", ";", "}", "}", "else", "{", "a", "=", "null", ";", "ret", ".", "add", "(", "s", ")", ";", "}", "if", "(", "a", "!=", "null", ")", "{", "if", "(", "a", ".", "isSwitch", ")", "{", "a", ".", "setField", "(", "\"true\"", ")", ";", "}", "else", "{", "if", "(", "i", "+", "1", ">=", "args", ".", "length", ")", "{", "System", ".", "out", ".", "println", "(", "\"Missing parameter for: \"", "+", "s", ")", ";", "}", "if", "(", "a", ".", "isCatchAll", "(", ")", ")", "{", "final", "List", "<", "String", ">", "ca", "=", "Colls", ".", "list", "(", ")", ";", "for", "(", "++", "i", ";", "i", "<", "args", ".", "length", ";", "++", "i", ")", "{", "ca", ".", "add", "(", "args", "[", "i", "]", ")", ";", "}", "a", ".", "setCatchAll", "(", "ca", ")", ";", "}", "else", "{", "++", "i", ";", "a", ".", "setField", "(", "args", "[", "i", "]", ")", ";", "}", "}", "a", ".", "setPresent", "(", ")", ";", "}", "}", "for", "(", "final", "Arg", "a", ":", "allArgs", ")", "{", "if", "(", "!", "a", ".", "isOk", "(", ")", ")", "{", "throw", "new", "IOException", "(", "\"Missing mandatory argument: \"", "+", "a", ")", ";", "}", "}", "return", "ret", ";", "}" ]

[ "Parses", "command", "line", "arguments", "." ]

[ "public", "final", "static", "int", "readUntil", "(", "final", "StringBuilder", "out", ",", "final", "String", "in", ",", "final", "int", "start", ",", "final", "char", "end", ")", "{", "int", "pos", "=", "start", ";", "while", "(", "pos", "<", "in", ".", "length", "(", ")", ")", "{", "final", "char", "ch", "=", "in", ".", "charAt", "(", "pos", ")", ";", "if", "(", "ch", "==", "'", "'", "&&", "pos", "+", "1", "<", "in", ".", "length", "(", ")", ")", "{", "pos", "=", "escape", "(", "out", ",", "in", ".", "charAt", "(", "pos", "+", "1", ")", ",", "pos", ")", ";", "}", "else", "{", "if", "(", "ch", "==", "end", ")", "{", "break", ";", "}", "out", ".", "append", "(", "ch", ")", ";", "}", "pos", "++", ";", "}", "return", "(", "pos", "==", "in", ".", "length", "(", ")", ")", "?", "-", "1", ":", "pos", ";", "}" ]

[ "Reads", "characters", "until", "the", "end", "character", "is", "encountered", "." ]

[ "public", "final", "static", "int", "readMdLink", "(", "final", "StringBuilder", "out", ",", "final", "String", "in", ",", "final", "int", "start", ")", "{", "int", "pos", "=", "start", ";", "int", "counter", "=", "1", ";", "while", "(", "pos", "<", "in", ".", "length", "(", ")", ")", "{", "final", "char", "ch", "=", "in", ".", "charAt", "(", "pos", ")", ";", "if", "(", "ch", "==", "'", "'", "&&", "pos", "+", "1", "<", "in", ".", "length", "(", ")", ")", "{", "pos", "=", "escape", "(", "out", ",", "in", ".", "charAt", "(", "pos", "+", "1", ")", ",", "pos", ")", ";", "}", "else", "{", "boolean", "endReached", "=", "false", ";", "switch", "(", "ch", ")", "{", "case", "'", "'", ":", "counter", "++", ";", "break", ";", "case", "'", "'", ":", "if", "(", "counter", "==", "1", ")", "{", "endReached", "=", "true", ";", "}", "break", ";", "case", "'", "'", ":", "counter", "--", ";", "if", "(", "counter", "==", "0", ")", "{", "endReached", "=", "true", ";", "}", "break", ";", "}", "if", "(", "endReached", ")", "{", "break", ";", "}", "out", ".", "append", "(", "ch", ")", ";", "}", "pos", "++", ";", "}", "return", "(", "pos", "==", "in", ".", "length", "(", ")", ")", "?", "-", "1", ":", "pos", ";", "}" ]

[ "Reads", "a", "markdown", "link", "." ]

[ "public", "final", "static", "int", "readMdLinkId", "(", "final", "StringBuilder", "out", ",", "final", "String", "in", ",", "final", "int", "start", ")", "{", "int", "pos", "=", "start", ";", "int", "counter", "=", "1", ";", "while", "(", "pos", "<", "in", ".", "length", "(", ")", ")", "{", "final", "char", "ch", "=", "in", ".", "charAt", "(", "pos", ")", ";", "boolean", "endReached", "=", "false", ";", "switch", "(", "ch", ")", "{", "case", "'", "'", ":", "out", ".", "append", "(", "'", "'", ")", ";", "break", ";", "case", "'", "'", ":", "counter", "++", ";", "out", ".", "append", "(", "ch", ")", ";", "break", ";", "case", "'", "'", ":", "counter", "--", ";", "if", "(", "counter", "==", "0", ")", "{", "endReached", "=", "true", ";", "}", "else", "{", "out", ".", "append", "(", "ch", ")", ";", "}", "break", ";", "default", ":", "out", ".", "append", "(", "ch", ")", ";", "break", ";", "}", "if", "(", "endReached", ")", "{", "break", ";", "}", "pos", "++", ";", "}", "return", "(", "pos", "==", "in", ".", "length", "(", ")", ")", "?", "-", "1", ":", "pos", ";", "}" ]

[ "Reads", "a", "markdown", "link", "ID", "." ]

[ "public", "final", "static", "int", "readXMLUntil", "(", "final", "StringBuilder", "out", ",", "final", "String", "in", ",", "final", "int", "start", ",", "final", "char", "...", "end", ")", "{", "int", "pos", "=", "start", ";", "boolean", "inString", "=", "false", ";", "char", "stringChar", "=", "0", ";", "while", "(", "pos", "<", "in", ".", "length", "(", ")", ")", "{", "final", "char", "ch", "=", "in", ".", "charAt", "(", "pos", ")", ";", "if", "(", "inString", ")", "{", "if", "(", "ch", "==", "'", "'", ")", "{", "out", ".", "append", "(", "ch", ")", ";", "pos", "++", ";", "if", "(", "pos", "<", "in", ".", "length", "(", ")", ")", "{", "out", ".", "append", "(", "ch", ")", ";", "pos", "++", ";", "}", "continue", ";", "}", "if", "(", "ch", "==", "stringChar", ")", "{", "inString", "=", "false", ";", "out", ".", "append", "(", "ch", ")", ";", "pos", "++", ";", "continue", ";", "}", "}", "switch", "(", "ch", ")", "{", "case", "'", "'", ":", "case", "'", "'", ":", "inString", "=", "true", ";", "stringChar", "=", "ch", ";", "break", ";", "}", "if", "(", "!", "inString", ")", "{", "boolean", "endReached", "=", "false", ";", "for", "(", "int", "n", "=", "0", ";", "n", "<", "end", ".", "length", ";", "n", "++", ")", "{", "if", "(", "ch", "==", "end", "[", "n", "]", ")", "{", "endReached", "=", "true", ";", "break", ";", "}", "}", "if", "(", "endReached", ")", "{", "break", ";", "}", "}", "out", ".", "append", "(", "ch", ")", ";", "pos", "++", ";", "}", "return", "(", "pos", "==", "in", ".", "length", "(", ")", ")", "?", "-", "1", ":", "pos", ";", "}" ]

[ "Reads", "characters", "until", "any", "end", "character", "is", "encountered", "ignoring", "escape", "sequences", "." ]

[ "public", "final", "static", "void", "appendCode", "(", "final", "StringBuilder", "out", ",", "final", "String", "in", ",", "final", "int", "start", ",", "final", "int", "end", ")", "{", "for", "(", "int", "i", "=", "start", ";", "i", "<", "end", ";", "i", "++", ")", "{", "final", "char", "c", ";", "switch", "(", "c", "=", "in", ".", "charAt", "(", "i", ")", ")", "{", "case", "'", "'", ":", "out", ".", "append", "(", "\"&amp;\"", ")", ";", "break", ";", "case", "'", "'", ":", "out", ".", "append", "(", "\"&lt;\"", ")", ";", "break", ";", "case", "'", "'", ":", "out", ".", "append", "(", "\"&gt;\"", ")", ";", "break", ";", "default", ":", "out", ".", "append", "(", "c", ")", ";", "break", ";", "}", "}", "}" ]

[ "Appends", "the", "given", "string", "encoding", "special", "HTML", "characters", "." ]

[ "public", "final", "static", "void", "appendDecEntity", "(", "final", "StringBuilder", "out", ",", "final", "char", "value", ")", "{", "out", ".", "append", "(", "\"&#\"", ")", ";", "out", ".", "append", "(", "(", "int", ")", "value", ")", ";", "out", ".", "append", "(", "'", "'", ")", ";", "}" ]

[ "Append", "the", "given", "char", "as", "a", "decimal", "HTML", "entity", "." ]

[ "public", "final", "static", "void", "codeEncode", "(", "final", "StringBuilder", "out", ",", "final", "String", "value", ",", "final", "int", "offset", ")", "{", "for", "(", "int", "i", "=", "offset", ";", "i", "<", "value", ".", "length", "(", ")", ";", "i", "++", ")", "{", "final", "char", "c", "=", "value", ".", "charAt", "(", "i", ")", ";", "switch", "(", "c", ")", "{", "case", "'", "'", ":", "out", ".", "append", "(", "\"&amp;\"", ")", ";", "break", ";", "case", "'", "'", ":", "out", ".", "append", "(", "\"&lt;\"", ")", ";", "break", ";", "case", "'", "'", ":", "out", ".", "append", "(", "\"&gt;\"", ")", ";", "break", ";", "default", ":", "out", ".", "append", "(", "c", ")", ";", "}", "}", "}" ]

[ "Appends", "the", "given", "string", "to", "the", "given", "StringBuilder", "replacing", "&amp", ";", "&lt", ";", "and", "&gt", ";", "by", "their", "respective", "HTML", "entities", "." ]

[ "private", "int", "countCharsStart", "(", "final", "char", "ch", ",", "final", "boolean", "allowSpaces", ")", "{", "int", "count", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "this", ".", "value", ".", "length", "(", ")", ";", "i", "++", ")", "{", "final", "char", "c", "=", "this", ".", "value", ".", "charAt", "(", "i", ")", ";", "if", "(", "c", "==", "'", "'", "&&", "allowSpaces", ")", "{", "continue", ";", "}", "if", "(", "c", "==", "ch", ")", "{", "count", "++", ";", "}", "else", "{", "break", ";", "}", "}", "return", "count", ";", "}" ]

[ "Counts", "the", "amount", "of", "ch", "at", "the", "start", "of", "this", "line", "optionally", "ignoring", "spaces", "." ]

[ "public", "SimplifySpanBuild", "append", "(", "String", "text", ")", "{", "if", "(", "TextUtils", ".", "isEmpty", "(", "text", ")", ")", "return", "this", ";", "mNormalSizeText", ".", "append", "(", "text", ")", ";", "mStringBuilder", ".", "append", "(", "text", ")", ";", "return", "this", ";", "}" ]

[ "append", "normal", "text" ]

[ "public", "SimplifySpanBuild", "appendMultiClickable", "(", "SpecialClickableUnit", "specialClickableUnit", ",", "Object", "...", "specialUnitOrStrings", ")", "{", "processMultiClickableSpecialUnit", "(", "false", ",", "specialClickableUnit", ",", "specialUnitOrStrings", ")", ";", "return", "this", ";", "}" ]

[ "append", "multi", "clickable", "SpecialUnit", "or", "String" ]

[ "@", "Override", "public", "void", "Invoke", "(", "final", "String", "method", ",", "JSONArray", "args", ",", "HubInvokeCallback", "callback", ")", "{", "if", "(", "method", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"method\"", ")", ";", "}", "if", "(", "args", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"args\"", ")", ";", "}", "final", "String", "callbackId", "=", "mConnection", ".", "RegisterCallback", "(", "callback", ")", ";", "HubInvocation", "hubData", "=", "new", "HubInvocation", "(", "mHubName", ",", "method", ",", "args", ",", "callbackId", ")", ";", "String", "value", "=", "hubData", ".", "Serialize", "(", ")", ";", "mConnection", ".", "Send", "(", "value", ",", "new", "SendCallback", "(", ")", "{", "@", "Override", "public", "void", "OnSent", "(", "CharSequence", "messageSent", ")", "{", "Log", ".", "v", "(", "TAG", ",", "\"Invoke of \"", "+", "method", "+", "\"sent to \"", "+", "mHubName", ")", ";", "// callback.OnSent() ??!?!?", "}", "@", "Override", "public", "void", "OnError", "(", "Exception", "ex", ")", "{", "// TODO Cancel the callback", "Log", ".", "e", "(", "TAG", ",", "\"Failed to invoke \"", "+", "method", "+", "\"on \"", "+", "mHubName", ")", ";", "mConnection", ".", "RemoveCallback", "(", "callbackId", ")", ";", "// callback.OnError() ?!?!?", "}", "}", ")", ";", "}" ]

[ "Executes", "a", "method", "on", "the", "server", "asynchronously" ]

[ "@", "IntRange", "(", "from", "=", "0", ",", "to", "=", "OPAQUE", ")", "private", "static", "int", "resolveLineAlpha", "(", "@", "IntRange", "(", "from", "=", "0", ",", "to", "=", "OPAQUE", ")", "final", "int", "sceneAlpha", ",", "final", "float", "maxDistance", ",", "final", "float", "distance", ")", "{", "final", "float", "alphaPercent", "=", "1f", "-", "distance", "/", "maxDistance", ";", "final", "int", "alpha", "=", "(", "int", ")", "(", "(", "float", ")", "OPAQUE", "*", "alphaPercent", ")", ";", "return", "alpha", "*", "sceneAlpha", "/", "OPAQUE", ";", "}" ]

[ "Resolves", "line", "alpha", "based", "on", "distance", "comparing", "to", "max", "distance", ".", "Where", "alpha", "is", "close", "to", "0", "for", "maxDistance", "and", "close", "to", "1", "to", "0", "distance", "." ]

[ "void", "applyFreshParticleOnScreen", "(", "@", "NonNull", "final", "Scene", "scene", ",", "final", "int", "position", ")", "{", "final", "int", "w", "=", "scene", ".", "getWidth", "(", ")", ";", "final", "int", "h", "=", "scene", ".", "getHeight", "(", ")", ";", "if", "(", "w", "==", "0", "||", "h", "==", "0", ")", "{", "throw", "new", "IllegalStateException", "(", "\"Cannot generate particles if scene width or height is 0\"", ")", ";", "}", "final", "double", "direction", "=", "Math", ".", "toRadians", "(", "random", ".", "nextInt", "(", "360", ")", ")", ";", "final", "float", "dCos", "=", "(", "float", ")", "Math", ".", "cos", "(", "direction", ")", ";", "final", "float", "dSin", "=", "(", "float", ")", "Math", ".", "sin", "(", "direction", ")", ";", "final", "float", "x", "=", "random", ".", "nextInt", "(", "w", ")", ";", "final", "float", "y", "=", "random", ".", "nextInt", "(", "h", ")", ";", "final", "float", "speedFactor", "=", "newRandomIndividualParticleSpeedFactor", "(", ")", ";", "final", "float", "radius", "=", "newRandomIndividualParticleRadius", "(", "scene", ")", ";", "scene", ".", "setParticleData", "(", "position", ",", "x", ",", "y", ",", "dCos", ",", "dSin", ",", "radius", ",", "speedFactor", ")", ";", "}" ]

[ "Set", "new", "point", "coordinates", "somewhere", "on", "screen", "and", "apply", "new", "direction" ]

[ "void", "applyFreshParticleOffScreen", "(", "@", "NonNull", "final", "Scene", "scene", ",", "final", "int", "position", ")", "{", "final", "int", "w", "=", "scene", ".", "getWidth", "(", ")", ";", "final", "int", "h", "=", "scene", ".", "getHeight", "(", ")", ";", "if", "(", "w", "==", "0", "||", "h", "==", "0", ")", "{", "throw", "new", "IllegalStateException", "(", "\"Cannot generate particles if scene width or height is 0\"", ")", ";", "}", "float", "x", "=", "random", ".", "nextInt", "(", "w", ")", ";", "float", "y", "=", "random", ".", "nextInt", "(", "h", ")", ";", "// The offset to make when creating point of out bounds", "final", "short", "offset", "=", "(", "short", ")", "(", "scene", ".", "getParticleRadiusMin", "(", ")", "+", "scene", ".", "getLineLength", "(", ")", ")", ";", "// Point angle range", "final", "float", "startAngle", ";", "float", "endAngle", ";", "// Make random offset and calulate angles so that the direction of travel will always be", "// towards our View", "switch", "(", "random", ".", "nextInt", "(", "4", ")", ")", "{", "case", "0", ":", "// offset to left", "x", "=", "(", "short", ")", "-", "offset", ";", "startAngle", "=", "angleDeg", "(", "pcc", ",", "pcc", ",", "x", ",", "y", ")", ";", "endAngle", "=", "angleDeg", "(", "pcc", ",", "h", "-", "pcc", ",", "x", ",", "y", ")", ";", "break", ";", "case", "1", ":", "// offset to top", "y", "=", "(", "short", ")", "-", "offset", ";", "startAngle", "=", "angleDeg", "(", "w", "-", "pcc", ",", "pcc", ",", "x", ",", "y", ")", ";", "endAngle", "=", "angleDeg", "(", "pcc", ",", "pcc", ",", "x", ",", "y", ")", ";", "break", ";", "case", "2", ":", "// offset to right", "x", "=", "(", "short", ")", "(", "w", "+", "offset", ")", ";", "startAngle", "=", "angleDeg", "(", "w", "-", "pcc", ",", "h", "-", "pcc", ",", "x", ",", "y", ")", ";", "endAngle", "=", "angleDeg", "(", "w", "-", "pcc", ",", "pcc", ",", "x", ",", "y", ")", ";", "break", ";", "case", "3", ":", "// offset to bottom", "y", "=", "(", "short", ")", "(", "h", "+", "offset", ")", ";", "startAngle", "=", "angleDeg", "(", "pcc", ",", "h", "-", "pcc", ",", "x", ",", "y", ")", ";", "endAngle", "=", "angleDeg", "(", "w", "-", "pcc", ",", "h", "-", "pcc", ",", "x", ",", "y", ")", ";", "break", ";", "default", ":", "throw", "new", "IllegalArgumentException", "(", "\"Supplied value out of range\"", ")", ";", "}", "if", "(", "endAngle", "<", "startAngle", ")", "{", "endAngle", "+=", "360", ";", "}", "// Get random angle from angle range", "final", "float", "randomAngleInRange", "=", "startAngle", "+", "(", "random", ".", "nextInt", "(", "(", "int", ")", "Math", ".", "abs", "(", "endAngle", "-", "startAngle", ")", ")", ")", ";", "final", "double", "direction", "=", "Math", ".", "toRadians", "(", "randomAngleInRange", ")", ";", "final", "float", "dCos", "=", "(", "float", ")", "Math", ".", "cos", "(", "direction", ")", ";", "final", "float", "dSin", "=", "(", "float", ")", "Math", ".", "sin", "(", "direction", ")", ";", "final", "float", "speedFactor", "=", "newRandomIndividualParticleSpeedFactor", "(", ")", ";", "final", "float", "radius", "=", "newRandomIndividualParticleRadius", "(", "scene", ")", ";", "scene", ".", "setParticleData", "(", "position", ",", "x", ",", "y", ",", "dCos", ",", "dSin", ",", "radius", ",", "speedFactor", ")", ";", "}" ]

[ "Set", "new", "particle", "coordinates", "somewhere", "off", "screen", "and", "apply", "new", "direction", "towards", "the", "screen" ]

[ "private", "static", "float", "angleDeg", "(", "final", "float", "ax", ",", "final", "float", "ay", ",", "final", "float", "bx", ",", "final", "float", "by", ")", "{", "final", "double", "angleRad", "=", "Math", ".", "atan2", "(", "ay", "-", "by", ",", "ax", "-", "bx", ")", ";", "double", "angle", "=", "Math", ".", "toDegrees", "(", "angleRad", ")", ";", "if", "(", "angleRad", "<", "0", ")", "{", "angle", "+=", "360", ";", "}", "return", "(", "float", ")", "angle", ";", "}" ]

[ "Returns", "angle", "in", "degrees", "between", "two", "points" ]

[ "private", "float", "newRandomIndividualParticleRadius", "(", "@", "NonNull", "final", "SceneConfiguration", "scene", ")", "{", "return", "scene", ".", "getParticleRadiusMin", "(", ")", "==", "scene", ".", "getParticleRadiusMax", "(", ")", "?", "scene", ".", "getParticleRadiusMin", "(", ")", ":", "scene", ".", "getParticleRadiusMin", "(", ")", "+", "(", "random", ".", "nextInt", "(", "(", "int", ")", "(", "(", "scene", ".", "getParticleRadiusMax", "(", ")", "-", "scene", ".", "getParticleRadiusMin", "(", ")", ")", "*", "100f", ")", ")", ")", "/", "100f", ";", "}" ]

[ "Generates", "new", "individual", "particle", "radius", "based", "on", "min", "and", "max", "radius", "setting", "." ]

[ "public", "static", "float", "distance", "(", "final", "float", "ax", ",", "final", "float", "ay", ",", "final", "float", "bx", ",", "final", "float", "by", ")", "{", "return", "(", "float", ")", "Math", ".", "sqrt", "(", "(", "ax", "-", "bx", ")", "*", "(", "ax", "-", "bx", ")", "+", "(", "ay", "-", "by", ")", "*", "(", "ay", "-", "by", ")", ")", ";", "}" ]

[ "Calculates", "the", "distance", "between", "two", "points" ]

[ "public", "Credentials", "toGrgit", "(", ")", "{", "if", "(", "username", "!=", "null", "&&", "password", "!=", "null", ")", "{", "return", "new", "Credentials", "(", "username", ",", "password", ")", ";", "}", "else", "{", "return", "null", ";", "}", "}" ]

[ "Converts", "to", "credentials", "for", "use", "in", "Grgit", "." ]

[ "@", "OnClick", "(", "R", ".", "id", ".", "navigateToSampleActivity", ")", "public", "void", "onSampleActivityCTAClick", "(", ")", "{", "StringParcel", "parcel1", "=", "new", "StringParcel", "(", "\"Andy\"", ")", ";", "StringParcel", "parcel2", "=", "new", "StringParcel", "(", "\"Tony\"", ")", ";", "List", "<", "StringParcel", ">", "parcelList", "=", "new", "ArrayList", "<>", "(", ")", ";", "parcelList", ".", "add", "(", "parcel1", ")", ";", "parcelList", ".", "add", "(", "parcel2", ")", ";", "SparseArray", "<", "StringParcel", ">", "parcelSparseArray", "=", "new", "SparseArray", "<>", "(", ")", ";", "parcelSparseArray", ".", "put", "(", "0", ",", "parcel1", ")", ";", "parcelSparseArray", ".", "put", "(", "2", ",", "parcel2", ")", ";", "Intent", "intent", "=", "HensonNavigator", ".", "gotoSampleActivity", "(", "this", ")", ".", "defaultKeyExtra", "(", "\"defaultKeyExtra\"", ")", ".", "extraInt", "(", "4", ")", ".", "extraListParcelable", "(", "parcelList", ")", ".", "extraParcel", "(", "parcel1", ")", ".", "extraParcelable", "(", "ComplexParcelable", ".", "random", "(", ")", ")", ".", "extraSparseArrayParcelable", "(", "parcelSparseArray", ")", ".", "extraString", "(", "\"a string\"", ")", ".", "build", "(", ")", ";", "startActivity", "(", "intent", ")", ";", "}" ]

[ "Launch", "Sample", "Activity", "residing", "in", "the", "same", "module" ]

[ "@", "OnClick", "(", "R", ".", "id", ".", "navigateToModule1Service", ")", "public", "void", "onNavigationServiceCTAClick", "(", ")", "{", "Intent", "intentService", "=", "HensonNavigator", ".", "gotoModule1Service", "(", "this", ")", ".", "stringExtra", "(", "\"foo\"", ")", ".", "build", "(", ")", ";", "startService", "(", "intentService", ")", ";", "}" ]

[ "Launch", "Navigation", "Service", "residing", "in", "the", "navigation", "module" ]

[ "public", "static", "boolean", "isValidFqcn", "(", "String", "str", ")", "{", "if", "(", "isNullOrEmpty", "(", "str", ")", ")", "{", "return", "false", ";", "}", "final", "String", "[", "]", "parts", "=", "str", ".", "split", "(", "\"\\\\.\"", ")", ";", "if", "(", "parts", ".", "length", "<", "2", ")", "{", "return", "false", ";", "}", "for", "(", "String", "part", ":", "parts", ")", "{", "if", "(", "!", "isValidJavaIdentifier", "(", "part", ")", ")", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}" ]

[ "Returns", "true", "if", "the", "string", "is", "a", "valid", "Java", "full", "qualified", "class", "name", "." ]

[ "public", "TaskProvider", "<", "GenerateHensonNavigatorTask", ">", "createHensonNavigatorGenerationTask", "(", "BaseVariant", "variant", ",", "String", "hensonNavigatorPackageName", ",", "File", "destinationFolder", ")", "{", "TaskProvider", "<", "GenerateHensonNavigatorTask", ">", "generateHensonNavigatorTask", "=", "project", ".", "getTasks", "(", ")", ".", "register", "(", "\"generate\"", "+", "capitalize", "(", "variant", ".", "getName", "(", ")", ")", "+", "\"HensonNavigator\"", ",", "GenerateHensonNavigatorTask", ".", "class", ",", "(", "Action", "<", "GenerateHensonNavigatorTask", ">", ")", "generateHensonNavigatorTask1", "->", "{", "generateHensonNavigatorTask1", ".", "hensonNavigatorPackageName", "=", "hensonNavigatorPackageName", ";", "generateHensonNavigatorTask1", ".", "destinationFolder", "=", "destinationFolder", ";", "generateHensonNavigatorTask1", ".", "variant", "=", "variant", ";", "generateHensonNavigatorTask1", ".", "logger", "=", "logger", ";", "generateHensonNavigatorTask1", ".", "project", "=", "project", ";", "generateHensonNavigatorTask1", ".", "hensonNavigatorGenerator", "=", "hensonNavigatorGenerator", ";", "}", ")", ";", "return", "generateHensonNavigatorTask", ";", "}" ]

[ "A", "henson", "navigator", "is", "a", "class", "that", "helps", "a", "consumer", "to", "consume", "the", "navigation", "api", "that", "it", "declares", "in", "its", "dependencies", ".", "The", "henson", "navigator", "will", "wrap", "the", "intent", "builders", ".", "Thus", "a", "henson", "navigator", "is", "driven", "by", "consumption", "of", "intent", "builders", "whereas", "the", "henson", "classes", "are", "driven", "by", "the", "production", "of", "an", "intent", "builder", "." ]

[ "public", "Bundler", "put", "(", "String", "key", ",", "Bundle", "value", ")", "{", "delegate", ".", "putBundle", "(", "key", ",", "value", ")", ";", "return", "this", ";", "}" ]

[ "Inserts", "a", "Bundle", "value", "into", "the", "mapping", "of", "the", "underlying", "Bundle", "replacing", "any", "existing", "value", "for", "the", "given", "key", ".", "Either", "key", "or", "value", "may", "be", "null", "." ]

[ "public", "Bundler", "put", "(", "String", "key", ",", "String", "value", ")", "{", "delegate", ".", "putString", "(", "key", ",", "value", ")", ";", "return", "this", ";", "}" ]

[ "Inserts", "a", "String", "value", "into", "the", "mapping", "of", "the", "underlying", "Bundle", "replacing", "any", "existing", "value", "for", "the", "given", "key", ".", "Either", "key", "or", "value", "may", "be", "null", "." ]

[ "public", "Bundler", "put", "(", "String", "key", ",", "String", "[", "]", "value", ")", "{", "delegate", ".", "putStringArray", "(", "key", ",", "value", ")", ";", "return", "this", ";", "}" ]

[ "Inserts", "a", "String", "array", "value", "into", "the", "mapping", "of", "the", "underlying", "Bundle", "replacing", "any", "existing", "value", "for", "the", "given", "key", ".", "Either", "key", "or", "value", "may", "be", "null", "." ]

[ "public", "Bundler", "put", "(", "String", "key", ",", "CharSequence", "value", ")", "{", "delegate", ".", "putCharSequence", "(", "key", ",", "value", ")", ";", "return", "this", ";", "}" ]

[ "Inserts", "a", "CharSequence", "value", "into", "the", "mapping", "of", "the", "underlying", "Bundle", "replacing", "any", "existing", "value", "for", "the", "given", "key", ".", "Either", "key", "or", "value", "may", "be", "null", "." ]

[ "public", "Bundler", "put", "(", "String", "key", ",", "CharSequence", "[", "]", "value", ")", "{", "delegate", ".", "putCharSequenceArray", "(", "key", ",", "value", ")", ";", "return", "this", ";", "}" ]

[ "Inserts", "a", "CharSequence", "array", "value", "into", "the", "mapping", "of", "the", "underlying", "Bundle", "replacing", "any", "existing", "value", "for", "the", "given", "key", ".", "Either", "key", "or", "value", "may", "be", "null", "." ]

[ "public", "Bundler", "put", "(", "String", "key", ",", "Parcelable", "value", ")", "{", "delegate", ".", "putParcelable", "(", "key", ",", "value", ")", ";", "return", "this", ";", "}" ]

[ "Inserts", "a", "Parcelable", "value", "into", "the", "mapping", "of", "the", "underlying", "Bundle", "replacing", "any", "existing", "value", "for", "the", "given", "key", ".", "Either", "key", "or", "value", "may", "be", "null", "." ]

[ "public", "Bundler", "put", "(", "String", "key", ",", "Parcelable", "[", "]", "value", ")", "{", "delegate", ".", "putParcelableArray", "(", "key", ",", "value", ")", ";", "return", "this", ";", "}" ]

[ "Inserts", "an", "array", "of", "Parcelable", "values", "into", "the", "mapping", "of", "the", "underlying", "Bundle", "replacing", "any", "existing", "value", "for", "the", "given", "key", ".", "Either", "key", "or", "value", "may", "be", "null", "." ]

[ "public", "Bundler", "put", "(", "String", "key", ",", "Serializable", "value", ")", "{", "delegate", ".", "putSerializable", "(", "key", ",", "value", ")", ";", "return", "this", ";", "}" ]

[ "Inserts", "a", "Serializable", "value", "into", "the", "mapping", "of", "the", "underlying", "Bundle", "replacing", "any", "existing", "value", "for", "the", "given", "key", ".", "Either", "key", "or", "value", "may", "be", "null", "." ]

[ "@", "Override", "public", "void", "validate", "(", ")", "throws", "HostNameException", "{", "if", "(", "parsedHost", "!=", "null", ")", "{", "return", ";", "}", "if", "(", "validationException", "!=", "null", ")", "{", "throw", "validationException", ";", "}", "synchronized", "(", "this", ")", "{", "if", "(", "parsedHost", "!=", "null", ")", "{", "return", ";", "}", "if", "(", "validationException", "!=", "null", ")", "{", "throw", "validationException", ";", "}", "try", "{", "parsedHost", "=", "getValidator", "(", ")", ".", "validateHost", "(", "this", ")", ";", "}", "catch", "(", "HostNameException", "e", ")", "{", "validationException", "=", "e", ";", "throw", "e", ";", "}", "}", "}" ]

[ "Validates", "that", "this", "string", "is", "a", "valid", "host", "name", "or", "IP", "address", "and", "if", "not", "throws", "an", "exception", "with", "a", "descriptive", "message", "indicating", "why", "it", "is", "not", "." ]

[ "public", "boolean", "isValid", "(", ")", "{", "if", "(", "parsedHost", "!=", "null", ")", "{", "return", "true", ";", "}", "if", "(", "validationException", "!=", "null", ")", "{", "return", "false", ";", "}", "try", "{", "validate", "(", ")", ";", "return", "true", ";", "}", "catch", "(", "HostNameException", "e", ")", "{", "return", "false", ";", "}", "}" ]

[ "Returns", "whether", "this", "represents", "a", "valid", "host", "name", "or", "address", "format", "." ]

[ "@", "Override", "public", "String", "toNormalizedString", "(", ")", "{", "String", "result", "=", "normalizedString", ";", "if", "(", "result", "==", "null", ")", "{", "normalizedString", "=", "result", "=", "toNormalizedString", "(", "false", ")", ";", "}", "return", "result", ";", "}" ]

[ "Provides", "a", "normalized", "string", "which", "is", "lowercase", "for", "host", "strings", "and", "which", "is", "a", "normalized", "string", "for", "addresses", "." ]

[ "public", "String", "[", "]", "getNormalizedLabels", "(", ")", "{", "if", "(", "isValid", "(", ")", ")", "{", "return", "parsedHost", ".", "getNormalizedLabels", "(", ")", ";", "}", "if", "(", "host", ".", "length", "(", ")", "==", "0", ")", "{", "return", "new", "String", "[", "0", "]", ";", "}", "return", "new", "String", "[", "]", "{", "host", "}", ";", "}" ]

[ "Returns", "an", "array", "of", "normalized", "strings", "for", "this", "host", "name", "instance", "." ]

[ "public", "boolean", "matches", "(", "HostName", "host", ")", "{", "if", "(", "this", "==", "host", ")", "{", "return", "true", ";", "}", "if", "(", "isValid", "(", ")", ")", "{", "if", "(", "host", ".", "isValid", "(", ")", ")", "{", "if", "(", "isAddressString", "(", ")", ")", "{", "return", "host", ".", "isAddressString", "(", ")", "&&", "asAddressString", "(", ")", ".", "equals", "(", "host", ".", "asAddressString", "(", ")", ")", "&&", "Objects", ".", "equals", "(", "getPort", "(", ")", ",", "host", ".", "getPort", "(", ")", ")", "&&", "Objects", ".", "equals", "(", "getService", "(", ")", ",", "host", ".", "getService", "(", ")", ")", ";", "}", "if", "(", "host", ".", "isAddressString", "(", ")", ")", "{", "return", "false", ";", "}", "String", "thisHost", "=", "parsedHost", ".", "getHost", "(", ")", ";", "String", "otherHost", "=", "host", ".", "parsedHost", ".", "getHost", "(", ")", ";", "if", "(", "!", "thisHost", ".", "equals", "(", "otherHost", ")", ")", "{", "return", "false", ";", "}", "return", "Objects", ".", "equals", "(", "parsedHost", ".", "getEquivalentPrefixLength", "(", ")", ",", "host", ".", "parsedHost", ".", "getEquivalentPrefixLength", "(", ")", ")", "&&", "Objects", ".", "equals", "(", "parsedHost", ".", "getMask", "(", ")", ",", "host", ".", "parsedHost", ".", "getMask", "(", ")", ")", "&&", "Objects", ".", "equals", "(", "parsedHost", ".", "getPort", "(", ")", ",", "host", ".", "parsedHost", ".", "getPort", "(", ")", ")", "&&", "Objects", ".", "equals", "(", "parsedHost", ".", "getService", "(", ")", ",", "host", ".", "parsedHost", ".", "getService", "(", ")", ")", ";", "}", "return", "false", ";", "}", "return", "!", "host", ".", "isValid", "(", ")", "&&", "toString", "(", ")", ".", "equals", "(", "host", ".", "toString", "(", ")", ")", ";", "}" ]

[ "Returns", "whether", "the", "given", "host", "matches", "this", "one", ".", "For", "hosts", "to", "match", "they", "must", "represent", "the", "same", "addresses", "or", "have", "the", "same", "host", "names", ".", "Hosts", "are", "not", "resolved", "when", "matching", ".", "Also", "hosts", "must", "have", "the", "same", "port", "and", "service", ".", "They", "must", "have", "the", "same", "masks", "if", "they", "are", "host", "names", ".", "Even", "if", "two", "hosts", "are", "invalid", "they", "match", "if", "they", "have", "the", "same", "invalid", "string", "." ]

[ "@", "Override", "public", "IPAddress", "toAddress", "(", ")", "throws", "UnknownHostException", ",", "HostNameException", "{", "IPAddress", "addr", "=", "resolvedAddress", ";", "if", "(", "addr", "==", "null", "&&", "!", "resolvedIsNull", ")", "{", "//note that validation handles empty address resolution", "validate", "(", ")", ";", "synchronized", "(", "this", ")", "{", "addr", "=", "resolvedAddress", ";", "if", "(", "addr", "==", "null", "&&", "!", "resolvedIsNull", ")", "{", "if", "(", "parsedHost", ".", "isAddressString", "(", ")", ")", "{", "addr", "=", "parsedHost", ".", "asAddress", "(", ")", ";", "resolvedIsNull", "=", "(", "addr", "==", "null", ")", ";", "//note there is no need to apply prefix or mask here, it would have been applied to the address already", "}", "else", "{", "String", "strHost", "=", "parsedHost", ".", "getHost", "(", ")", ";", "if", "(", "strHost", ".", "length", "(", ")", "==", "0", "&&", "!", "validationOptions", ".", "emptyIsLoopback", ")", "{", "addr", "=", "null", ";", "resolvedIsNull", "=", "true", ";", "}", "else", "{", "//Note we do not set resolvedIsNull, so we will attempt to resolve again if the previous attempt threw an exception", "InetAddress", "inetAddress", "=", "InetAddress", ".", "getByName", "(", "strHost", ")", ";", "byte", "bytes", "[", "]", "=", "inetAddress", ".", "getAddress", "(", ")", ";", "Integer", "networkPrefixLength", "=", "parsedHost", ".", "getNetworkPrefixLength", "(", ")", ";", "if", "(", "networkPrefixLength", "==", "null", ")", "{", "IPAddress", "mask", "=", "parsedHost", ".", "getMask", "(", ")", ";", "if", "(", "mask", "!=", "null", ")", "{", "byte", "maskBytes", "[", "]", "=", "mask", ".", "getBytes", "(", ")", ";", "if", "(", "maskBytes", ".", "length", "!=", "bytes", ".", "length", ")", "{", "throw", "new", "HostNameException", "(", "host", ",", "\"ipaddress.error.ipMismatch\"", ")", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "bytes", ".", "length", ";", "i", "++", ")", "{", "bytes", "[", "i", "]", "&=", "maskBytes", "[", "i", "]", ";", "}", "networkPrefixLength", "=", "mask", ".", "getBlockMaskPrefixLength", "(", "true", ")", ";", "}", "}", "IPAddressStringParameters", "addressParams", "=", "validationOptions", ".", "addressOptions", ";", "if", "(", "bytes", ".", "length", "==", "IPv6Address", ".", "BYTE_COUNT", ")", "{", "IPv6AddressCreator", "creator", "=", "addressParams", ".", "getIPv6Parameters", "(", ")", ".", "getNetwork", "(", ")", ".", "getAddressCreator", "(", ")", ";", "addr", "=", "creator", ".", "createAddressInternal", "(", "bytes", ",", "networkPrefixLength", ",", "null", ",", "this", ")", ";", "/* address creation */", "}", "else", "{", "IPv4AddressCreator", "creator", "=", "addressParams", ".", "getIPv4Parameters", "(", ")", ".", "getNetwork", "(", ")", ".", "getAddressCreator", "(", ")", ";", "addr", "=", "creator", ".", "createAddressInternal", "(", "bytes", ",", "networkPrefixLength", ",", "this", ")", ";", "/* address creation */", "}", "}", "}", "resolvedAddress", "=", "addr", ";", "}", "}", "}", "return", "addr", ";", "}" ]

[ "If", "this", "represents", "an", "ip", "address", "returns", "that", "address", ".", "If", "this", "represents", "a", "host", "returns", "the", "resolved", "ip", "address", "of", "that", "host", ".", "Otherwise", "returns", "null", "but", "only", "for", "strings", "that", "are", "considered", "valid", "address", "strings", "but", "cannot", "be", "converted", "to", "address", "objects", "." ]

[ "protected", "Iterator", "<", "MACAddress", ">", "iterator", "(", "MACAddress", "original", ")", "{", "MACAddressCreator", "creator", "=", "getAddressCreator", "(", ")", ";", "boolean", "isSingle", "=", "!", "isMultiple", "(", ")", ";", "return", "iterator", "(", "isSingle", "?", "original", ":", "null", ",", "creator", ",", "//using a lambda for this one results in a big performance hit\r", "isSingle", "?", "null", ":", "segmentsIterator", "(", ")", ",", "getNetwork", "(", ")", ".", "getPrefixConfiguration", "(", ")", ".", "allPrefixedAddressesAreSubnets", "(", ")", "?", "null", ":", "getPrefixLength", "(", ")", ")", ";", "}" ]

[ "these", "are", "the", "iterators", "used", "by", "MACAddress" ]

[ "@", "Override", "public", "String", "toHexString", "(", "boolean", "with0xPrefix", ")", "{", "String", "result", ";", "if", "(", "hasNoStringCache", "(", ")", "||", "(", "result", "=", "(", "with0xPrefix", "?", "stringCache", ".", "hexStringPrefixed", ":", "stringCache", ".", "hexString", ")", ")", "==", "null", ")", "{", "result", "=", "toHexString", "(", "with0xPrefix", ",", "null", ")", ";", "if", "(", "with0xPrefix", ")", "{", "stringCache", ".", "hexStringPrefixed", "=", "result", ";", "}", "else", "{", "stringCache", ".", "hexString", "=", "result", ";", "}", "}", "return", "result", ";", "}" ]

[ "Writes", "this", "address", "as", "a", "single", "hexadecimal", "value", "with", "always", "the", "exact", "same", "number", "of", "characters", "with", "or", "without", "a", "preceding", "0x", "prefix", "." ]

[ "@", "Override", "public", "String", "toCompressedString", "(", ")", "{", "String", "result", ";", "if", "(", "hasNoStringCache", "(", ")", "||", "(", "result", "=", "getStringCache", "(", ")", ".", "compressedString", ")", "==", "null", ")", "{", "getStringCache", "(", ")", ".", "compressedString", "=", "result", "=", "toNormalizedString", "(", "MACStringCache", ".", "compressedParams", ")", ";", "}", "return", "result", ";", "}" ]

[ "This", "produces", "a", "shorter", "string", "for", "the", "address", "that", "uses", "the", "canonical", "representation", "but", "not", "using", "leading", "zeroes", "." ]

[ "public", "String", "toDottedString", "(", ")", "{", "String", "result", "=", "null", ";", "if", "(", "hasNoStringCache", "(", ")", "||", "(", "result", "=", "getStringCache", "(", ")", ".", "dottedString", ")", "==", "null", ")", "{", "AddressDivisionGrouping", "dottedGrouping", "=", "getDottedGrouping", "(", ")", ";", "getStringCache", "(", ")", ".", "dottedString", "=", "result", "=", "toNormalizedString", "(", "MACStringCache", ".", "dottedParams", ",", "dottedGrouping", ")", ";", "}", "return", "result", ";", "}" ]

[ "This", "produces", "the", "dotted", "hexadecimal", "format", "aaaa", ".", "bbbb", ".", "cccc" ]

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

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

[ "@", "Override", "public", "boolean", "containsPrefixBlock", "(", "int", "prefixLength", ")", "{", "checkSubnet", "(", "this", ",", "prefixLength", ")", ";", "int", "divisionCount", "=", "getDivisionCount", "(", ")", ";", "int", "prevBitCount", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "divisionCount", ";", "i", "++", ")", "{", "AddressDivision", "division", "=", "getDivision", "(", "i", ")", ";", "int", "bitCount", "=", "division", ".", "getBitCount", "(", ")", ";", "int", "totalBitCount", "=", "bitCount", "+", "prevBitCount", ";", "if", "(", "prefixLength", "<", "totalBitCount", ")", "{", "int", "divPrefixLen", "=", "Math", ".", "max", "(", "0", ",", "prefixLength", "-", "prevBitCount", ")", ";", "if", "(", "!", "division", ".", "isPrefixBlock", "(", "division", ".", "getDivisionValue", "(", ")", ",", "division", ".", "getUpperDivisionValue", "(", ")", ",", "divPrefixLen", ")", ")", "{", "return", "false", ";", "}", "for", "(", "++", "i", ";", "i", "<", "divisionCount", ";", "i", "++", ")", "{", "division", "=", "getDivision", "(", "i", ")", ";", "if", "(", "!", "division", ".", "isFullRange", "(", ")", ")", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}", "prevBitCount", "=", "totalBitCount", ";", "}", "return", "true", ";", "}" ]

[ "Returns", "whether", "the", "values", "of", "this", "division", "grouping", "contain", "the", "prefix", "block", "for", "the", "given", "prefix", "length" ]

[ "protected", "static", "<", "S", "extends", "IPAddressSegment", ">", "void", "normalizePrefixBoundary", "(", "int", "sectionPrefixBits", ",", "S", "segments", "[", "]", ",", "int", "segmentBitCount", ",", "int", "segmentByteCount", ",", "BiFunction", "<", "S", ",", "Integer", ",", "S", ">", "segProducer", ")", "{", "//we've already verified segment prefixes in super constructor. We simply need to check the case where the prefix is at a segment boundary,", "//whether the network side has the correct prefix", "int", "networkSegmentIndex", "=", "getNetworkSegmentIndex", "(", "sectionPrefixBits", ",", "segmentByteCount", ",", "segmentBitCount", ")", ";", "if", "(", "networkSegmentIndex", ">=", "0", ")", "{", "S", "segment", "=", "segments", "[", "networkSegmentIndex", "]", ";", "if", "(", "!", "segment", ".", "isPrefixed", "(", ")", ")", "{", "segments", "[", "networkSegmentIndex", "]", "=", "segProducer", ".", "apply", "(", "segment", ",", "segmentBitCount", ")", ";", "}", "}", "}" ]

[ "In", "the", "case", "where", "the", "prefix", "sits", "at", "a", "segment", "boundary", "and", "the", "prefix", "sequence", "is", "null", "-", "null", "-", "0", "this", "changes", "to", "prefix", "sequence", "of", "null", "-", "x", "-", "0", "where", "x", "is", "segment", "bit", "length", "." ]

[ "protected", "static", "<", "R", "extends", "AddressSection", ",", "S", "extends", "AddressSegment", ">", "R", "fastIncrement", "(", "R", "section", ",", "long", "increment", ",", "AddressCreator", "<", "?", ",", "R", ",", "?", ",", "S", ">", "addrCreator", ",", "Supplier", "<", "R", ">", "lowerProducer", ",", "Supplier", "<", "R", ">", "upperProducer", ",", "Integer", "prefixLength", ")", "{", "if", "(", "increment", ">=", "0", ")", "{", "BigInteger", "count", "=", "section", ".", "getCount", "(", ")", ";", "if", "(", "count", ".", "compareTo", "(", "LONG_MAX", ")", "<=", "0", ")", "{", "long", "longCount", "=", "count", ".", "longValue", "(", ")", ";", "if", "(", "longCount", ">", "increment", ")", "{", "if", "(", "longCount", "==", "increment", "+", "1", ")", "{", "return", "upperProducer", ".", "get", "(", ")", ";", "}", "return", "incrementRange", "(", "section", ",", "increment", ",", "addrCreator", ",", "lowerProducer", ",", "prefixLength", ")", ";", "}", "BigInteger", "value", "=", "section", ".", "getValue", "(", ")", ";", "BigInteger", "upperValue", ";", "if", "(", "value", ".", "compareTo", "(", "LONG_MAX", ")", "<=", "0", "&&", "(", "upperValue", "=", "section", ".", "getUpperValue", "(", ")", ")", ".", "compareTo", "(", "LONG_MAX", ")", "<=", "0", ")", "{", "return", "increment", "(", "section", ",", "increment", ",", "addrCreator", ",", "count", ".", "longValue", "(", ")", ",", "value", ".", "longValue", "(", ")", ",", "upperValue", ".", "longValue", "(", ")", ",", "lowerProducer", ",", "upperProducer", ",", "prefixLength", ")", ";", "}", "}", "}", "else", "{", "BigInteger", "value", "=", "section", ".", "getValue", "(", ")", ";", "if", "(", "value", ".", "compareTo", "(", "LONG_MAX", ")", "<=", "0", ")", "{", "return", "add", "(", "lowerProducer", ".", "get", "(", ")", ",", "value", ".", "longValue", "(", ")", ",", "increment", ",", "addrCreator", ",", "prefixLength", ")", ";", "}", "}", "return", "null", ";", "}" ]

[ "Handles", "the", "cases", "in", "which", "we", "can", "use", "longs", "rather", "than", "BigInteger" ]

[ "public", "StringBuilder", "getSQLCondition", "(", "StringBuilder", "builder", ",", "String", "columnName", ")", "{", "String", "string", "=", "networkString", ".", "getString", "(", ")", ";", "if", "(", "isEntireAddress", ")", "{", "matchString", "(", "builder", ",", "columnName", ",", "string", ")", ";", "}", "else", "{", "matchSubString", "(", "builder", ",", "columnName", ",", "networkString", ".", "getTrailingSegmentSeparator", "(", ")", ",", "networkString", ".", "getTrailingSeparatorCount", "(", ")", "+", "1", ",", "string", ")", ";", "}", "return", "builder", ";", "}" ]

[ "Get", "an", "SQL", "condition", "to", "match", "this", "address", "section", "representation" ]

[ "protected", "static", "BigInteger", "getRadixPower", "(", "BigInteger", "radix", ",", "int", "power", ")", "{", "long", "key", "=", "(", "(", "(", "long", ")", "radix", ".", "intValue", "(", ")", ")", "<<", "32", ")", "|", "power", ";", "BigInteger", "result", "=", "radixPowerMap", ".", "get", "(", "key", ")", ";", "if", "(", "result", "==", "null", ")", "{", "if", "(", "power", "==", "1", ")", "{", "result", "=", "radix", ";", "}", "else", "if", "(", "(", "power", "&", "1", ")", "==", "0", ")", "{", "BigInteger", "halfPower", "=", "getRadixPower", "(", "radix", ",", "power", ">>", "1", ")", ";", "result", "=", "halfPower", ".", "multiply", "(", "halfPower", ")", ";", "}", "else", "{", "BigInteger", "halfPower", "=", "getRadixPower", "(", "radix", ",", "(", "power", "-", "1", ")", ">>", "1", ")", ";", "result", "=", "halfPower", ".", "multiply", "(", "halfPower", ")", ".", "multiply", "(", "radix", ")", ";", "}", "radixPowerMap", ".", "put", "(", "key", ",", "result", ")", ";", "}", "return", "result", ";", "}" ]

[ "Caches", "the", "results", "of", "radix", "to", "the", "given", "power", "." ]

[ "protected", "byte", "[", "]", "getBytesInternal", "(", ")", "{", "byte", "cached", "[", "]", ";", "if", "(", "hasNoValueCache", "(", ")", "||", "(", "cached", "=", "valueCache", ".", "lowerBytes", ")", "==", "null", ")", "{", "valueCache", ".", "lowerBytes", "=", "cached", "=", "getBytesImpl", "(", "true", ")", ";", "}", "return", "cached", ";", "}" ]

[ "gets", "the", "bytes", "sharing", "the", "cached", "array", "and", "does", "not", "clone", "it" ]

[ "protected", "byte", "[", "]", "getUpperBytesInternal", "(", ")", "{", "byte", "cached", "[", "]", ";", "if", "(", "hasNoValueCache", "(", ")", ")", "{", "ValueCache", "cache", "=", "valueCache", ";", "cache", ".", "upperBytes", "=", "cached", "=", "getBytesImpl", "(", "false", ")", ";", "if", "(", "!", "isMultiple", "(", ")", ")", "{", "cache", ".", "lowerBytes", "=", "cached", ";", "}", "}", "else", "{", "ValueCache", "cache", "=", "valueCache", ";", "if", "(", "(", "cached", "=", "cache", ".", "upperBytes", ")", "==", "null", ")", "{", "if", "(", "!", "isMultiple", "(", ")", ")", "{", "if", "(", "(", "cached", "=", "cache", ".", "lowerBytes", ")", "!=", "null", ")", "{", "cache", ".", "upperBytes", "=", "cached", ";", "}", "else", "{", "cache", ".", "lowerBytes", "=", "cache", ".", "upperBytes", "=", "cached", "=", "getBytesImpl", "(", "false", ")", ";", "}", "}", "else", "{", "cache", ".", "upperBytes", "=", "cached", "=", "getBytesImpl", "(", "false", ")", ";", "}", "}", "}", "return", "cached", ";", "}" ]

[ "Gets", "the", "bytes", "for", "the", "highest", "address", "in", "the", "range", "represented", "by", "this", "address", "." ]

[ "@", "Override", "public", "int", "getMinPrefixLengthForBlock", "(", ")", "{", "int", "count", "=", "getDivisionCount", "(", ")", ";", "int", "totalPrefix", "=", "getBitCount", "(", ")", ";", "for", "(", "int", "i", "=", "count", "-", "1", ";", "i", ">=", "0", ";", "i", "--", ")", "{", "AddressDivisionBase", "div", "=", "getDivision", "(", "i", ")", ";", "int", "segBitCount", "=", "div", ".", "getBitCount", "(", ")", ";", "int", "segPrefix", "=", "div", ".", "getMinPrefixLengthForBlock", "(", ")", ";", "if", "(", "segPrefix", "==", "segBitCount", ")", "{", "break", ";", "}", "else", "{", "totalPrefix", "-=", "segBitCount", ";", "if", "(", "segPrefix", "!=", "0", ")", "{", "totalPrefix", "+=", "segPrefix", ";", "break", ";", "}", "}", "}", "return", "totalPrefix", ";", "}" ]

[ "Returns", "the", "smallest", "prefix", "length", "possible", "such", "that", "this", "address", "division", "grouping", "includes", "the", "block", "of", "addresses", "for", "that", "prefix", "." ]

[ "@", "Override", "public", "Integer", "getPrefixLengthForSingleBlock", "(", ")", "{", "int", "count", "=", "getDivisionCount", "(", ")", ";", "int", "totalPrefix", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "count", ";", "i", "++", ")", "{", "AddressDivisionBase", "div", "=", "getDivision", "(", "i", ")", ";", "Integer", "divPrefix", "=", "div", ".", "getPrefixLengthForSingleBlock", "(", ")", ";", "if", "(", "divPrefix", "==", "null", ")", "{", "return", "null", ";", "}", "totalPrefix", "+=", "divPrefix", ";", "if", "(", "divPrefix", "<", "div", ".", "getBitCount", "(", ")", ")", "{", "//remaining segments must be full range or we return null", "for", "(", "i", "++", ";", "i", "<", "count", ";", "i", "++", ")", "{", "AddressDivisionBase", "laterDiv", "=", "getDivision", "(", "i", ")", ";", "if", "(", "!", "laterDiv", ".", "isFullRange", "(", ")", ")", "{", "return", "null", ";", "}", "}", "}", "}", "return", "cacheBits", "(", "totalPrefix", ")", ";", "}" ]

[ "Returns", "a", "prefix", "length", "for", "which", "the", "range", "of", "this", "segment", "grouping", "matches", "the", "the", "block", "of", "addresses", "for", "that", "prefix", "." ]

[ "@", "Override", "public", "BigInteger", "getCount", "(", ")", "{", "BigInteger", "cached", "=", "cachedCount", ";", "if", "(", "cached", "==", "null", ")", "{", "cachedCount", "=", "cached", "=", "getCountImpl", "(", ")", ";", "}", "return", "cached", ";", "}" ]

[ "gets", "the", "count", "of", "addresses", "that", "this", "address", "division", "grouping", "may", "represent" ]

[ "public", "static", "int", "validateZone", "(", "CharSequence", "zone", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "zone", ".", "length", "(", ")", ";", "i", "++", ")", "{", "char", "c", "=", "zone", ".", "charAt", "(", "i", ")", ";", "if", "(", "c", "==", "IPAddress", ".", "PREFIX_LEN_SEPARATOR", ")", "{", "return", "i", ";", "}", "if", "(", "c", "==", "IPv6Address", ".", "SEGMENT_SEPARATOR", ")", "{", "return", "i", ";", "}", "}", "return", "-", "1", ";", "}" ]

[ "Returns", "the", "index", "of", "the", "first", "invalid", "character", "of", "the", "zone", "or", "-", "1", "if", "the", "zone", "is", "valid" ]

[ "private", "static", "long", "switchValue8", "(", "long", "currentHexValue", ",", "int", "digitCount", ")", "{", "long", "result", "=", "0x7", "&", "currentHexValue", ";", "int", "shift", "=", "0", ";", "while", "(", "--", "digitCount", ">", "0", ")", "{", "shift", "+=", "3", ";", "currentHexValue", ">>>=", "4", ";", "result", "|=", "(", "0x7", "&", "currentHexValue", ")", "<<", "shift", ";", "}", "return", "result", ";", "}" ]

[ "The", "digits", "were", "stored", "as", "a", "hex", "value", "thix", "switches", "them", "to", "an", "octal", "value", "." ]

[ "static", "ParsedHost", "validateHostImpl", "(", "HostName", "fromHost", ")", "throws", "HostNameException", "{", "final", "String", "str", "=", "fromHost", ".", "toString", "(", ")", ";", "HostNameParameters", "validationOptions", "=", "fromHost", ".", "getValidationOptions", "(", ")", ";", "return", "validateHost", "(", "fromHost", ",", "str", ",", "validationOptions", ")", ";", "}" ]

[ "So", "we", "will", "follow", "rfc", "1035", "and", "in", "addition", "allow", "the", "underscore", "." ]

[ "private", "static", "CharSequence", "convertReverseDNSIPv4", "(", "String", "str", ",", "int", "suffixStartIndex", ")", "throws", "AddressStringException", "{", "StringBuilder", "builder", "=", "new", "StringBuilder", "(", "suffixStartIndex", ")", ";", "int", "segCount", "=", "0", ";", "int", "j", "=", "suffixStartIndex", ";", "for", "(", "int", "i", "=", "suffixStartIndex", "-", "1", ";", "i", ">", "0", ";", "i", "--", ")", "{", "char", "c1", "=", "str", ".", "charAt", "(", "i", ")", ";", "if", "(", "c1", "==", "IPv4Address", ".", "SEGMENT_SEPARATOR", ")", "{", "if", "(", "j", "-", "i", "<=", "1", ")", "{", "throw", "new", "AddressStringException", "(", "str", ",", "i", ")", ";", "}", "for", "(", "int", "k", "=", "i", "+", "1", ";", "k", "<", "j", ";", "k", "++", ")", "{", "builder", ".", "append", "(", "str", ".", "charAt", "(", "k", ")", ")", ";", "}", "builder", ".", "append", "(", "c1", ")", ";", "j", "=", "i", ";", "segCount", "++", ";", "}", "}", "for", "(", "int", "k", "=", "0", ";", "k", "<", "j", ";", "k", "++", ")", "{", "builder", ".", "append", "(", "str", ".", "charAt", "(", "k", ")", ")", ";", "}", "if", "(", "segCount", "+", "1", "!=", "IPv4Address", ".", "SEGMENT_COUNT", ")", "{", "throw", "new", "AddressStringException", "(", "str", ",", "0", ")", ";", "}", "return", "builder", ";", "}" ]

[ "123", ".", "2", ".", "3", ".", "4", "is", "4", ".", "3", ".", "2", ".", "123", ".", "in", "-", "addr", ".", "arpa", "." ]

[ "protected", "boolean", "isPrefixBlock", "(", "long", "divisionValue", ",", "long", "upperValue", ",", "int", "divisionPrefixLen", ")", "{", "if", "(", "divisionPrefixLen", "==", "0", ")", "{", "return", "divisionValue", "==", "0", "&&", "upperValue", "==", "getMaxValue", "(", ")", ";", "}", "long", "ones", "=", "~", "0L", ";", "long", "divisionBitMask", "=", "~", "(", "ones", "<<", "getBitCount", "(", ")", ")", ";", "long", "divisionPrefixMask", "=", "ones", "<<", "(", "getBitCount", "(", ")", "-", "divisionPrefixLen", ")", ";", "long", "divisionNonPrefixMask", "=", "~", "divisionPrefixMask", ";", "return", "testRange", "(", "divisionValue", ",", "upperValue", ",", "upperValue", ",", "divisionPrefixMask", "&", "divisionBitMask", ",", "divisionNonPrefixMask", ")", ";", "}" ]

[ "Returns", "whether", "the", "division", "range", "includes", "the", "block", "of", "values", "for", "its", "prefix", "length" ]

[ "public", "boolean", "matchesWithMask", "(", "long", "lowerValue", ",", "long", "upperValue", ",", "long", "mask", ")", "{", "if", "(", "lowerValue", "==", "upperValue", ")", "{", "return", "matchesWithMask", "(", "lowerValue", ",", "mask", ")", ";", "}", "if", "(", "!", "isMultiple", "(", ")", ")", "{", "//we know lowerValue and upperValue are not the same, so impossible to match those two values with a single value", "return", "false", ";", "}", "long", "thisValue", "=", "getDivisionValue", "(", ")", ";", "long", "thisUpperValue", "=", "getUpperDivisionValue", "(", ")", ";", "if", "(", "!", "isMaskCompatibleWithRange", "(", "thisValue", ",", "thisUpperValue", ",", "mask", ",", "getMaxValue", "(", ")", ")", ")", "{", "return", "false", ";", "}", "return", "lowerValue", "==", "(", "thisValue", "&", "mask", ")", "&&", "upperValue", "==", "(", "thisUpperValue", "&", "mask", ")", ";", "}" ]

[ "returns", "whether", "masking", "with", "the", "given", "mask", "results", "in", "a", "valid", "contiguous", "range", "for", "this", "segment", "and", "if", "it", "does", "if", "it", "matches", "the", "range", "obtained", "when", "masking", "the", "given", "values", "with", "the", "same", "mask", "." ]

[ "protected", "static", "boolean", "isMaskCompatibleWithRange", "(", "long", "value", ",", "long", "upperValue", ",", "long", "maskValue", ",", "long", "maxValue", ")", "{", "if", "(", "value", "==", "upperValue", "||", "maskValue", "==", "maxValue", "||", "maskValue", "==", "0", ")", "{", "return", "true", ";", "}", "//algorithm:", "//here we find the highest bit that is part of the range, highestDifferingBitInRange (ie changes from lower to upper)", "//then we find the highest bit in the mask that is 1 that is the same or below highestDifferingBitInRange (if such a bit exists)", "//this gives us the highest bit that is part of the masked range (ie changes from lower to upper after applying the mask)", "//if this latter bit exists, then any bit below it in the mask must be 1 to include the entire range.", "long", "differing", "=", "value", "^", "upperValue", ";", "boolean", "foundDiffering", "=", "(", "differing", "!=", "0", ")", ";", "boolean", "differingIsLowestBit", "=", "(", "differing", "==", "1", ")", ";", "if", "(", "foundDiffering", "&&", "!", "differingIsLowestBit", ")", "{", "int", "highestDifferingBitInRange", "=", "Long", ".", "numberOfLeadingZeros", "(", "differing", ")", ";", "long", "maskMask", "=", "~", "0L", ">>>", "highestDifferingBitInRange", ";", "long", "differingMasked", "=", "maskValue", "&", "maskMask", ";", "foundDiffering", "=", "(", "differingMasked", "!=", "0", ")", ";", "differingIsLowestBit", "=", "(", "differingMasked", "==", "1", ")", ";", "if", "(", "foundDiffering", "&&", "!", "differingIsLowestBit", ")", "{", "//anything below highestDifferingBitMasked in the mask must be ones", "//Also, if we have masked out any 1 bit in the original, then anything that we do not mask out that follows must be all 1s", "int", "highestDifferingBitMasked", "=", "Long", ".", "numberOfLeadingZeros", "(", "differingMasked", ")", ";", "long", "hostMask", "=", "~", "0L", ">>>", "(", "highestDifferingBitMasked", "+", "1", ")", ";", "//for the first mask bit that is 1, all bits that follow must also be 1", "if", "(", "(", "maskValue", "&", "hostMask", ")", "!=", "hostMask", ")", "{", "//check if all ones below", "return", "false", ";", "}", "if", "(", "highestDifferingBitMasked", ">", "highestDifferingBitInRange", ")", "{", "//We have masked out a 1 bit, so we need to check that all bits in upper value that we do not mask out are also 1 bits, otherwise we end up missing values in the masked range", "//This check is unnecessary for prefix-length subnets, only non-standard ranges might fail this check.", "//For instance, if we have range 0000 to 1010", "//and we mask upper and lower with 0111", "//we get 0000 to 0010, but 0111 was in original range, and the mask of that value retains that value", "//so that value needs to be in final range, and it's not.", "//What went wrong is that we masked out the top bit, and any other bit that is not masked out must be 1.", "//To work, our original range needed to be 0000 to 1111, with the three 1s following the first masked-out 1", "long", "hostMaskUpper", "=", "~", "0L", ">>>", "highestDifferingBitMasked", ";", "if", "(", "(", "upperValue", "&", "hostMaskUpper", ")", "!=", "hostMaskUpper", ")", "{", "return", "false", ";", "}", "}", "}", "}", "return", "true", ";", "}" ]

[ "when", "divisionPrefixLen", "is", "null", "isAutoSubnets", "has", "no", "effect" ]

[ "public", "boolean", "isEUI64", "(", "boolean", "partial", ")", "{", "int", "segmentCount", "=", "getSegmentCount", "(", ")", ";", "int", "endIndex", "=", "addressSegmentIndex", "+", "segmentCount", ";", "if", "(", "addressSegmentIndex", "<=", "5", ")", "{", "if", "(", "endIndex", ">", "6", ")", "{", "int", "index3", "=", "5", "-", "addressSegmentIndex", ";", "IPv6AddressSegment", "seg3", "=", "getSegment", "(", "index3", ")", ";", "IPv6AddressSegment", "seg4", "=", "getSegment", "(", "index3", "+", "1", ")", ";", "return", "seg4", ".", "matchesWithMask", "(", "0xfe00", ",", "0xff00", ")", "&&", "seg3", ".", "matchesWithMask", "(", "0xff", ",", "0xff", ")", ";", "}", "else", "if", "(", "partial", "&&", "endIndex", "==", "6", ")", "{", "IPv6AddressSegment", "seg3", "=", "getSegment", "(", "5", "-", "addressSegmentIndex", ")", ";", "return", "seg3", ".", "matchesWithMask", "(", "0xff", ",", "0xff", ")", ";", "}", "}", "else", "if", "(", "partial", "&&", "addressSegmentIndex", "==", "6", "&&", "endIndex", ">", "6", ")", "{", "IPv6AddressSegment", "seg4", "=", "getSegment", "(", "6", "-", "addressSegmentIndex", ")", ";", "return", "seg4", ".", "matchesWithMask", "(", "0xfe00", ",", "0xff00", ")", ";", "}", "return", "partial", ";", "}" ]

[ "Whether", "this", "section", "is", "consistent", "with", "an", "EUI64", "section", "which", "means", "it", "came", "from", "an", "extended", "8", "byte", "address", "and", "the", "corresponding", "segments", "in", "the", "middle", "match", "0xff", "and", "0xfe" ]

[ "public", "MACAddressSection", "toEUI", "(", "boolean", "extended", ")", "{", "MACAddressSegment", "[", "]", "segs", "=", "toEUISegments", "(", "extended", ")", ";", "if", "(", "segs", "==", "null", ")", "{", "return", "null", ";", "}", "MACAddressCreator", "creator", "=", "getMACNetwork", "(", ")", ".", "getAddressCreator", "(", ")", ";", "return", "createSectionInternal", "(", "creator", ",", "segs", ",", "Math", ".", "max", "(", "0", ",", "addressSegmentIndex", "-", "4", ")", "<<", "1", ",", "extended", ")", ";", "}" ]

[ "Returns", "the", "corresponding", "mac", "section", "or", "null", "if", "this", "address", "section", "does", "not", "correspond", "to", "a", "mac", "section", ".", "If", "this", "address", "section", "has", "a", "prefix", "length", "it", "is", "ignored", "." ]