code stringlengths 73 34.1k | label stringclasses 1 value |
|---|---|
private long interpolateTimeFromUpdate(TrackPositionUpdate lastTrackUpdate, CdjStatus newDeviceUpdate,
BeatGrid beatGrid) {
final int beatNumber = newDeviceUpdate.getBeatNumber();
final boolean noLongerPlaying = !newDeviceUpdate.isPlaying();
// If we have just stopped, see if we are near a cue (assuming that information is available), and if so,
// the best assumption is that the DJ jumped to that cue.
if (lastTrackUpdate.playing && noLongerPlaying) {
final CueList.Entry jumpedTo = findAdjacentCue(newDeviceUpdate, beatGrid);
if (jumpedTo != null) return jumpedTo.cueTime;
}
// Handle the special case where we were not playing either in the previous or current update, but the DJ
// might have jumped to a different place in the track.
if (!lastTrackUpdate.playing) {
if (lastTrackUpdate.beatNumber == beatNumber && noLongerPlaying) { // Haven't moved
return lastTrackUpdate.milliseconds;
} else {
if (noLongerPlaying) { // Have jumped without playing.
if (beatNumber < 0) {
return -1; // We don't know the position any more; weird to get into this state and still have a grid?
}
// As a heuristic, assume we are right before the beat?
return timeOfBeat(beatGrid, beatNumber, newDeviceUpdate);
}
}
}
// One way or another, we are now playing.
long elapsedMillis = (newDeviceUpdate.getTimestamp() - lastTrackUpdate.timestamp) / 1000000;
long moved = Math.round(lastTrackUpdate.pitch * elapsedMillis);
long interpolated = (lastTrackUpdate.reverse)?
(lastTrackUpdate.milliseconds - moved) : lastTrackUpdate.milliseconds + moved;
if (Math.abs(beatGrid.findBeatAtTime(interpolated) - beatNumber) < 2) {
return interpolated; // Our calculations still look plausible
}
// The player has jumped or drifted somewhere unexpected, correct.
if (newDeviceUpdate.isPlayingForwards()) {
return timeOfBeat(beatGrid, beatNumber, newDeviceUpdate);
} else {
return beatGrid.getTimeWithinTrack(Math.min(beatNumber + 1, beatGrid.beatCount));
}
} | java |
public long getTimeFor(int player) {
TrackPositionUpdate update = positions.get(player);
if (update != null) {
return interpolateTimeSinceUpdate(update, System.nanoTime());
}
return -1; // We don't know.
} | java |
private boolean interpolationsDisagree(TrackPositionUpdate lastUpdate, TrackPositionUpdate currentUpdate) {
long now = System.nanoTime();
return Math.abs(interpolateTimeSinceUpdate(lastUpdate, now) - interpolateTimeSinceUpdate(currentUpdate, now)) >
slack.get();
} | java |
@SuppressWarnings("WeakerAccess")
public synchronized void stop() {
if (isRunning()) {
BeatFinder.getInstance().removeBeatListener(beatListener);
VirtualCdj.getInstance().removeUpdateListener(updateListener);
running.set(false);
positions.clear();
updates.clear();
deliverLifecycleAnnouncement(logger, false);
}
} | java |
public static synchronized DeckReference getDeckReference(int player, int hotCue) {
Map<Integer, DeckReference> playerMap = instances.get(player);
if (playerMap == null) {
playerMap = new HashMap<Integer, DeckReference>();
instances.put(player, playerMap);
}
DeckReference result = playerMap.get(hotCue);
if (result == null) {
result = new DeckReference(player, hotCue);
playerMap.put(hotCue, result);
}
return result;
} | java |
public synchronized void setDeviceName(String name) {
if (name.getBytes().length > DEVICE_NAME_LENGTH) {
throw new IllegalArgumentException("name cannot be more than " + DEVICE_NAME_LENGTH + " bytes long");
}
Arrays.fill(announcementBytes, DEVICE_NAME_OFFSET, DEVICE_NAME_LENGTH, (byte)0);
System.arraycopy(name.getBytes(), 0, announcementBytes, DEVICE_NAME_OFFSET, name.getBytes().length);
} | java |
private void setTempoMaster(DeviceUpdate newMaster) {
DeviceUpdate oldMaster = tempoMaster.getAndSet(newMaster);
if ((newMaster == null && oldMaster != null) ||
(newMaster != null && ((oldMaster == null) || !newMaster.getAddress().equals(oldMaster.getAddress())))) {
// This is a change in master, so report it to any registered listeners
deliverMasterChangedAnnouncement(newMaster);
}
} | java |
private void setMasterTempo(double newTempo) {
double oldTempo = Double.longBitsToDouble(masterTempo.getAndSet(Double.doubleToLongBits(newTempo)));
if ((getTempoMaster() != null) && (Math.abs(newTempo - oldTempo) > getTempoEpsilon())) {
// This is a change in tempo, so report it to any registered listeners, and update our metronome if we are synced.
if (isSynced()) {
metronome.setTempo(newTempo);
notifyBeatSenderOfChange();
}
deliverTempoChangedAnnouncement(newTempo);
}
} | java |
private void processUpdate(DeviceUpdate update) {
updates.put(update.getAddress(), update);
// Keep track of the largest sync number we see.
if (update instanceof CdjStatus) {
int syncNumber = ((CdjStatus)update).getSyncNumber();
if (syncNumber > this.largestSyncCounter.get()) {
this.largestSyncCounter.set(syncNumber);
}
}
// Deal with the tempo master complexities, including handoff to/from us.
if (update.isTempoMaster()) {
final Integer packetYieldingTo = update.getDeviceMasterIsBeingYieldedTo();
if (packetYieldingTo == null) {
// This is a normal, non-yielding master packet. Update our notion of the current master, and,
// if we were yielding, finish that process, updating our sync number appropriately.
if (master.get()) {
if (nextMaster.get() == update.deviceNumber) {
syncCounter.set(largestSyncCounter.get() + 1);
} else {
if (nextMaster.get() == 0xff) {
logger.warn("Saw master asserted by player " + update.deviceNumber +
" when we were not yielding it.");
} else {
logger.warn("Expected to yield master role to player " + nextMaster.get() +
" but saw master asserted by player " + update.deviceNumber);
}
}
}
master.set(false);
nextMaster.set(0xff);
setTempoMaster(update);
setMasterTempo(update.getEffectiveTempo());
} else {
// This is a yielding master packet. If it is us that is being yielded to, take over master.
// Log a message if it was unsolicited, and a warning if it's coming from a different player than
// we asked.
if (packetYieldingTo == getDeviceNumber()) {
if (update.deviceNumber != masterYieldedFrom.get()) {
if (masterYieldedFrom.get() == 0) {
logger.info("Accepting unsolicited Master yield; we must be the only synced device playing.");
} else {
logger.warn("Expected player " + masterYieldedFrom.get() + " to yield master to us, but player " +
update.deviceNumber + " did.");
}
}
master.set(true);
masterYieldedFrom.set(0);
setTempoMaster(null);
setMasterTempo(getTempo());
}
}
} else {
// This update was not acting as a tempo master; if we thought it should be, update our records.
DeviceUpdate oldMaster = getTempoMaster();
if (oldMaster != null && oldMaster.getAddress().equals(update.getAddress())) {
// This device has resigned master status, and nobody else has claimed it so far
setTempoMaster(null);
}
}
deliverDeviceUpdate(update);
} | java |
void processBeat(Beat beat) {
if (isRunning() && beat.isTempoMaster()) {
setMasterTempo(beat.getEffectiveTempo());
deliverBeatAnnouncement(beat);
}
} | java |
private InterfaceAddress findMatchingAddress(DeviceAnnouncement aDevice, NetworkInterface networkInterface) {
for (InterfaceAddress address : networkInterface.getInterfaceAddresses()) {
if ((address.getBroadcast() != null) &&
Util.sameNetwork(address.getNetworkPrefixLength(), aDevice.getAddress(), address.getAddress())) {
return address;
}
}
return null;
} | java |
public Set<DeviceAnnouncement> findUnreachablePlayers() {
ensureRunning();
Set<DeviceAnnouncement> result = new HashSet<DeviceAnnouncement>();
for (DeviceAnnouncement candidate: DeviceFinder.getInstance().getCurrentDevices()) {
if (!Util.sameNetwork(matchedAddress.getNetworkPrefixLength(), matchedAddress.getAddress(), candidate.getAddress())) {
result.add(candidate);
}
}
return Collections.unmodifiableSet(result);
} | java |
public synchronized void stop() {
if (isRunning()) {
try {
setSendingStatus(false);
} catch (Throwable t) {
logger.error("Problem stopping sending status during shutdown", t);
}
DeviceFinder.getInstance().removeIgnoredAddress(socket.get().getLocalAddress());
socket.get().close();
socket.set(null);
broadcastAddress.set(null);
updates.clear();
setTempoMaster(null);
setDeviceNumber((byte)0); // Set up for self-assignment if restarted.
deliverLifecycleAnnouncement(logger, false);
}
} | java |
private void sendAnnouncement(InetAddress broadcastAddress) {
try {
DatagramPacket announcement = new DatagramPacket(announcementBytes, announcementBytes.length,
broadcastAddress, DeviceFinder.ANNOUNCEMENT_PORT);
socket.get().send(announcement);
Thread.sleep(getAnnounceInterval());
} catch (Throwable t) {
logger.warn("Unable to send announcement packet, shutting down", t);
stop();
}
} | java |
private void deliverMasterChangedAnnouncement(final DeviceUpdate update) {
for (final MasterListener listener : getMasterListeners()) {
try {
listener.masterChanged(update);
} catch (Throwable t) {
logger.warn("Problem delivering master changed announcement to listener", t);
}
}
} | java |
private void deliverTempoChangedAnnouncement(final double tempo) {
for (final MasterListener listener : getMasterListeners()) {
try {
listener.tempoChanged(tempo);
} catch (Throwable t) {
logger.warn("Problem delivering tempo changed announcement to listener", t);
}
}
} | java |
private void deliverBeatAnnouncement(final Beat beat) {
for (final MasterListener listener : getMasterListeners()) {
try {
listener.newBeat(beat);
} catch (Throwable t) {
logger.warn("Problem delivering master beat announcement to listener", t);
}
}
} | java |
private void deliverDeviceUpdate(final DeviceUpdate update) {
for (DeviceUpdateListener listener : getUpdateListeners()) {
try {
listener.received(update);
} catch (Throwable t) {
logger.warn("Problem delivering device update to listener", t);
}
}
} | java |
private void deliverMediaDetailsUpdate(final MediaDetails details) {
for (MediaDetailsListener listener : getMediaDetailsListeners()) {
try {
listener.detailsAvailable(details);
} catch (Throwable t) {
logger.warn("Problem delivering media details response to listener", t);
}
}
} | java |
@SuppressWarnings("SameParameterValue")
private void assembleAndSendPacket(Util.PacketType kind, byte[] payload, InetAddress destination, int port) throws IOException {
DatagramPacket packet = Util.buildPacket(kind,
ByteBuffer.wrap(announcementBytes, DEVICE_NAME_OFFSET, DEVICE_NAME_LENGTH).asReadOnlyBuffer(),
ByteBuffer.wrap(payload));
packet.setAddress(destination);
packet.setPort(port);
socket.get().send(packet);
} | java |
private void sendSyncControlCommand(DeviceUpdate target, byte command) throws IOException {
ensureRunning();
byte[] payload = new byte[SYNC_CONTROL_PAYLOAD.length];
System.arraycopy(SYNC_CONTROL_PAYLOAD, 0, payload, 0, SYNC_CONTROL_PAYLOAD.length);
payload[2] = getDeviceNumber();
payload[8] = getDeviceNumber();
payload[12] = command;
assembleAndSendPacket(Util.PacketType.SYNC_CONTROL, payload, target.getAddress(), BeatFinder.BEAT_PORT);
} | java |
public void sendSyncModeCommand(int deviceNumber, boolean synced) throws IOException {
final DeviceUpdate update = getLatestStatusFor(deviceNumber);
if (update == null) {
throw new IllegalArgumentException("Device " + deviceNumber + " not found on network.");
}
sendSyncModeCommand(update, synced);
} | java |
public void appointTempoMaster(int deviceNumber) throws IOException {
final DeviceUpdate update = getLatestStatusFor(deviceNumber);
if (update == null) {
throw new IllegalArgumentException("Device " + deviceNumber + " not found on network.");
}
appointTempoMaster(update);
} | java |
public void sendFaderStartCommand(Set<Integer> deviceNumbersToStart, Set<Integer> deviceNumbersToStop) throws IOException {
ensureRunning();
byte[] payload = new byte[FADER_START_PAYLOAD.length];
System.arraycopy(FADER_START_PAYLOAD, 0, payload, 0, FADER_START_PAYLOAD.length);
payload[2] = getDeviceNumber();
for (int i = 1; i <= 4; i++) {
if (deviceNumbersToStart.contains(i)) {
payload[i + 4] = 0;
}
if (deviceNumbersToStop.contains(i)) {
payload[i + 4] = 1;
}
}
assembleAndSendPacket(Util.PacketType.FADER_START_COMMAND, payload, getBroadcastAddress(), BeatFinder.BEAT_PORT);
} | java |
public void sendLoadTrackCommand(int targetPlayer, int rekordboxId,
int sourcePlayer, CdjStatus.TrackSourceSlot sourceSlot, CdjStatus.TrackType sourceType)
throws IOException {
final DeviceUpdate update = getLatestStatusFor(targetPlayer);
if (update == null) {
throw new IllegalArgumentException("Device " + targetPlayer + " not found on network.");
}
sendLoadTrackCommand(update, rekordboxId, sourcePlayer, sourceSlot, sourceType);
} | java |
public void sendLoadTrackCommand(DeviceUpdate target, int rekordboxId,
int sourcePlayer, CdjStatus.TrackSourceSlot sourceSlot, CdjStatus.TrackType sourceType)
throws IOException {
ensureRunning();
byte[] payload = new byte[LOAD_TRACK_PAYLOAD.length];
System.arraycopy(LOAD_TRACK_PAYLOAD, 0, payload, 0, LOAD_TRACK_PAYLOAD.length);
payload[0x02] = getDeviceNumber();
payload[0x05] = getDeviceNumber();
payload[0x09] = (byte)sourcePlayer;
payload[0x0a] = sourceSlot.protocolValue;
payload[0x0b] = sourceType.protocolValue;
Util.numberToBytes(rekordboxId, payload, 0x0d, 4);
assembleAndSendPacket(Util.PacketType.LOAD_TRACK_COMMAND, payload, target.getAddress(), UPDATE_PORT);
} | java |
public synchronized void setSendingStatus(boolean send) throws IOException {
if (isSendingStatus() == send) {
return;
}
if (send) { // Start sending status packets.
ensureRunning();
if ((getDeviceNumber() < 1) || (getDeviceNumber() > 4)) {
throw new IllegalStateException("Can only send status when using a standard player number, 1 through 4.");
}
BeatFinder.getInstance().start();
BeatFinder.getInstance().addLifecycleListener(beatFinderLifecycleListener);
final AtomicBoolean stillRunning = new AtomicBoolean(true);
sendingStatus = stillRunning; // Allow other threads to stop us when necessary.
Thread sender = new Thread(null, new Runnable() {
@Override
public void run() {
while (stillRunning.get()) {
sendStatus();
try {
Thread.sleep(getStatusInterval());
} catch (InterruptedException e) {
logger.warn("beat-link VirtualCDJ status sender thread was interrupted; continuing");
}
}
}
}, "beat-link VirtualCdj status sender");
sender.setDaemon(true);
sender.start();
if (isSynced()) { // If we are supposed to be synced, we need to respond to master beats and tempo changes.
addMasterListener(ourSyncMasterListener);
}
if (isPlaying()) { // Start the beat sender too, if we are supposed to be playing.
beatSender.set(new BeatSender(metronome));
}
} else { // Stop sending status packets, and responding to master beats and tempo changes if we were synced.
BeatFinder.getInstance().removeLifecycleListener(beatFinderLifecycleListener);
removeMasterListener(ourSyncMasterListener);
sendingStatus.set(false); // Stop the status sending thread.
sendingStatus = null; // Indicate that we are no longer sending status.
final BeatSender activeSender = beatSender.get(); // And stop the beat sender if we have one.
if (activeSender != null) {
activeSender.shutDown();
beatSender.set(null);
}
}
} | java |
public void setPlaying(boolean playing) {
if (this.playing.get() == playing) {
return;
}
this.playing.set(playing);
if (playing) {
metronome.jumpToBeat(whereStopped.get().getBeat());
if (isSendingStatus()) { // Need to also start the beat sender.
beatSender.set(new BeatSender(metronome));
}
} else {
final BeatSender activeSender = beatSender.get();
if (activeSender != null) { // We have a beat sender we need to stop.
activeSender.shutDown();
beatSender.set(null);
}
whereStopped.set(metronome.getSnapshot());
}
} | java |
public synchronized void becomeTempoMaster() throws IOException {
logger.debug("Trying to become master.");
if (!isSendingStatus()) {
throw new IllegalStateException("Must be sending status updates to become the tempo master.");
}
// Is there someone we need to ask to yield to us?
final DeviceUpdate currentMaster = getTempoMaster();
if (currentMaster != null) {
// Send the yield request; we will become master when we get a successful response.
byte[] payload = new byte[MASTER_HANDOFF_REQUEST_PAYLOAD.length];
System.arraycopy(MASTER_HANDOFF_REQUEST_PAYLOAD, 0, payload, 0, MASTER_HANDOFF_REQUEST_PAYLOAD.length);
payload[2] = getDeviceNumber();
payload[8] = getDeviceNumber();
if (logger.isDebugEnabled()) {
logger.debug("Sending master yield request to player " + currentMaster);
}
requestingMasterRoleFromPlayer.set(currentMaster.deviceNumber);
assembleAndSendPacket(Util.PacketType.MASTER_HANDOFF_REQUEST, payload, currentMaster.address, BeatFinder.BEAT_PORT);
} else if (!master.get()) {
// There is no other master, we can just become it immediately.
requestingMasterRoleFromPlayer.set(0);
setMasterTempo(getTempo());
master.set(true);
}
} | java |
public synchronized void setSynced(boolean sync) {
if (synced.get() != sync) {
// We are changing sync state, so add or remove our master listener as appropriate.
if (sync && isSendingStatus()) {
addMasterListener(ourSyncMasterListener);
} else {
removeMasterListener(ourSyncMasterListener);
}
// Also, if there is a tempo master, and we just got synced, adopt its tempo.
if (!isTempoMaster() && getTempoMaster() != null) {
setTempo(getMasterTempo());
}
}
synced.set(sync);
} | java |
public synchronized void jumpToBeat(int beat) {
if (beat < 1) {
beat = 1;
} else {
beat = wrapBeat(beat);
}
if (playing.get()) {
metronome.jumpToBeat(beat);
} else {
whereStopped.set(metronome.getSnapshot(metronome.getTimeOfBeat(beat)));
}
} | java |
public Set<PlaybackState> getPlaybackState() {
Set<PlaybackState> result = new HashSet<PlaybackState>(playbackStateMap.values());
return Collections.unmodifiableSet(result);
} | java |
private void setPlaybackPosition(long milliseconds) {
PlaybackState oldState = currentSimpleState();
if (oldState != null && oldState.position != milliseconds) {
setPlaybackState(oldState.player, milliseconds, oldState.playing);
}
} | java |
private void setPlaying(boolean playing) {
PlaybackState oldState = currentSimpleState();
if (oldState != null && oldState.playing != playing) {
setPlaybackState(oldState.player, oldState.position, playing);
}
} | java |
public synchronized void setMonitoredPlayer(final int player) {
if (player < 0) {
throw new IllegalArgumentException("player cannot be negative");
}
clearPlaybackState();
monitoredPlayer.set(player);
if (player > 0) { // Start monitoring the specified player
setPlaybackState(player, 0, false); // Start with default values for required simple state.
VirtualCdj.getInstance().addUpdateListener(updateListener);
MetadataFinder.getInstance().addTrackMetadataListener(metadataListener);
cueList.set(null); // Assume the worst, but see if we have one available next.
if (MetadataFinder.getInstance().isRunning()) {
TrackMetadata metadata = MetadataFinder.getInstance().getLatestMetadataFor(player);
if (metadata != null) {
cueList.set(metadata.getCueList());
}
}
WaveformFinder.getInstance().addWaveformListener(waveformListener);
if (WaveformFinder.getInstance().isRunning() && WaveformFinder.getInstance().isFindingDetails()) {
waveform.set(WaveformFinder.getInstance().getLatestDetailFor(player));
} else {
waveform.set(null);
}
BeatGridFinder.getInstance().addBeatGridListener(beatGridListener);
if (BeatGridFinder.getInstance().isRunning()) {
beatGrid.set(BeatGridFinder.getInstance().getLatestBeatGridFor(player));
} else {
beatGrid.set(null);
}
try {
TimeFinder.getInstance().start();
if (!animating.getAndSet(true)) {
// Create the thread to update our position smoothly as the track plays
new Thread(new Runnable() {
@Override
public void run() {
while (animating.get()) {
try {
Thread.sleep(33); // Animate at 30 fps
} catch (InterruptedException e) {
logger.warn("Waveform animation thread interrupted; ending");
animating.set(false);
}
setPlaybackPosition(TimeFinder.getInstance().getTimeFor(getMonitoredPlayer()));
}
}
}).start();
}
} catch (Exception e) {
logger.error("Unable to start the TimeFinder to animate the waveform detail view");
animating.set(false);
}
} else { // Stop monitoring any player
animating.set(false);
VirtualCdj.getInstance().removeUpdateListener(updateListener);
MetadataFinder.getInstance().removeTrackMetadataListener(metadataListener);
WaveformFinder.getInstance().removeWaveformListener(waveformListener);
cueList.set(null);
waveform.set(null);
beatGrid.set(null);
}
if (!autoScroll.get()) {
invalidate();
}
repaint();
} | java |
public PlaybackState getFurthestPlaybackState() {
PlaybackState result = null;
for (PlaybackState state : playbackStateMap.values()) {
if (result == null || (!result.playing && state.playing) ||
(result.position < state.position) && (state.playing || !result.playing)) {
result = state;
}
}
return result;
} | java |
private int getSegmentForX(int x) {
if (autoScroll.get()) {
int playHead = (x - (getWidth() / 2));
int offset = Util.timeToHalfFrame(getFurthestPlaybackPosition()) / scale.get();
return (playHead + offset) * scale.get();
}
return x * scale.get();
} | java |
public int getXForBeat(int beat) {
BeatGrid grid = beatGrid.get();
if (grid != null) {
return millisecondsToX(grid.getTimeWithinTrack(beat));
}
return 0;
} | java |
public int millisecondsToX(long milliseconds) {
if (autoScroll.get()) {
int playHead = (getWidth() / 2) + 2;
long offset = milliseconds - getFurthestPlaybackPosition();
return playHead + (Util.timeToHalfFrame(offset) / scale.get());
}
return Util.timeToHalfFrame(milliseconds) / scale.get();
} | java |
public static Color cueColor(CueList.Entry entry) {
if (entry.hotCueNumber > 0) {
return Color.GREEN;
}
if (entry.isLoop) {
return Color.ORANGE;
}
return Color.RED;
} | java |
public byte[] getPacketBytes() {
byte[] result = new byte[packetBytes.length];
System.arraycopy(packetBytes, 0, result, 0, packetBytes.length);
return result;
} | java |
public static DatagramPacket buildPacket(PacketType type, ByteBuffer deviceName, ByteBuffer payload) {
ByteBuffer content = ByteBuffer.allocate(0x1f + payload.remaining());
content.put(getMagicHeader());
content.put(type.protocolValue);
content.put(deviceName);
content.put(payload);
return new DatagramPacket(content.array(), content.capacity());
} | java |
public static PacketType validateHeader(DatagramPacket packet, int port) {
byte[] data = packet.getData();
if (data.length < PACKET_TYPE_OFFSET) {
logger.warn("Packet is too short to be a Pro DJ Link packet; must be at least " + PACKET_TYPE_OFFSET +
" bytes long, was only " + data.length + ".");
return null;
}
if (!getMagicHeader().equals(ByteBuffer.wrap(data, 0, MAGIC_HEADER.length))) {
logger.warn("Packet did not have correct nine-byte header for the Pro DJ Link protocol.");
return null;
}
final Map<Byte, PacketType> portMap = PACKET_TYPE_MAP.get(port);
if (portMap == null) {
logger.warn("Do not know any Pro DJ Link packets that are received on port " + port + ".");
return null;
}
final PacketType result = portMap.get(data[PACKET_TYPE_OFFSET]);
if (result == null) {
logger.warn("Do not know any Pro DJ Link packets received on port " + port + " with type " +
String.format("0x%02x", data[PACKET_TYPE_OFFSET]) + ".");
}
return result;
} | java |
public static long bytesToNumber(byte[] buffer, int start, int length) {
long result = 0;
for (int index = start; index < start + length; index++) {
result = (result << 8) + unsign(buffer[index]);
}
return result;
} | java |
@SuppressWarnings("SameParameterValue")
public static long bytesToNumberLittleEndian(byte[] buffer, int start, int length) {
long result = 0;
for (int index = start + length - 1; index >= start; index--) {
result = (result << 8) + unsign(buffer[index]);
}
return result;
} | java |
public static void numberToBytes(int number, byte[] buffer, int start, int length) {
for (int index = start + length - 1; index >= start; index--) {
buffer[index] = (byte)(number & 0xff);
number = number >> 8;
}
} | java |
public static long addressToLong(InetAddress address) {
long result = 0;
for (byte element : address.getAddress()) {
result = (result << 8) + unsign(element);
}
return result;
} | java |
public static boolean sameNetwork(int prefixLength, InetAddress address1, InetAddress address2) {
if (logger.isDebugEnabled()) {
logger.debug("Comparing address " + address1.getHostAddress() + " with " + address2.getHostAddress() + ", prefixLength=" + prefixLength);
}
long prefixMask = 0xffffffffL & (-1 << (32 - prefixLength));
return (addressToLong(address1) & prefixMask) == (addressToLong(address2) & prefixMask);
} | java |
public static void writeFully(ByteBuffer buffer, WritableByteChannel channel) throws IOException {
while (buffer.hasRemaining()) {
channel.write(buffer);
}
} | java |
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));
} | java |
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);
}
}
}
});
} | java |
private void digestInteger(MessageDigest digest, int value) {
byte[] valueBytes = new byte[4];
Util.numberToBytes(value, valueBytes, 0, 4);
digest.update(valueBytes);
} | java |
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
} | java |
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);
}
}
} | java |
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);
} | java |
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.
}
} | java |
private void updateDevices(DeviceAnnouncement announcement) {
firstDeviceTime.compareAndSet(0, System.currentTimeMillis());
devices.put(announcement.getAddress(), announcement);
} | java |
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();
}
} | java |
@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);
}
} | java |
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);
}
}
});
}
} | java |
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);
}
}
});
}
} | java |
private void performSetupExchange() throws IOException {
Message setupRequest = new Message(0xfffffffeL, 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());
}
} | java |
private void performTeardownExchange() throws IOException {
Message teardownRequest = new Message(0xfffffffeL, Message.KnownType.TEARDOWN_REQ);
sendMessage(teardownRequest);
// At this point, the server closes the connection from its end, so we can’t read any more.
} | java |
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);
}
} | java |
@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");
} | java |
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);
} | java |
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;
} | java |
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;
} | java |
@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;
} | java |
@SuppressWarnings("WeakerAccess")
public static SlotReference getSlotReference(DataReference dataReference) {
return getSlotReference(dataReference.player, dataReference.slot);
} | java |
@Override
public boolean isTempoMaster() {
DeviceUpdate master = VirtualCdj.getInstance().getTempoMaster();
return (master != null) && master.getAddress().equals(address);
} | java |
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();
} | java |
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);
} | java |
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);
}
}
} | java |
@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);
}
} | java |
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);
}
} | java |
private int getMaxHeight() {
int result = 0;
for (int i = 0; i < segmentCount; i++) {
result = Math.max(result, segmentHeight(i, false));
}
return result;
} | java |
@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;
}
} | java |
@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;
}
} | java |
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;
} | java |
public byte[] getValueAsArray() {
ByteBuffer buffer = getValue();
byte[] result = new byte[buffer.remaining()];
buffer.get(result);
return result;
} | java |
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;
} | java |
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);
} | java |
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())));
}
}
} | java |
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;
}
} | java |
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;
} | java |
public final static String process(final File file, final boolean safeMode) throws IOException
{
return process(file, Configuration.builder().setSafeMode(safeMode).build());
} | java |
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();
}
} | java |
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;
} | java |
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;
} | java |
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;
} | java |
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 '\n':
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;
} | java |
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;
} | java |
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("&");
break;
case '<':
out.append("<");
break;
case '>':
out.append(">");
break;
default:
out.append(c);
break;
}
}
} | java |
public final static void appendDecEntity(final StringBuilder out, final char value)
{
out.append("&#");
out.append((int)value);
out.append(';');
} | java |
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("&");
break;
case '<':
out.append("<");
break;
case '>':
out.append(">");
break;
default:
out.append(c);
}
}
} | java |
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;
} | java |
public SimplifySpanBuild append(String text) {
if (TextUtils.isEmpty(text)) return this;
mNormalSizeText.append(text);
mStringBuilder.append(text);
return this;
} | java |
public SimplifySpanBuild appendMultiClickable(SpecialClickableUnit specialClickableUnit, Object... specialUnitOrStrings) {
processMultiClickableSpecialUnit(false, specialClickableUnit, specialUnitOrStrings);
return this;
} | java |
@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() ?!?!?
}
});
} | java |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.