package org.asteriskjava.live.internal;
import java.util.Date;
import org.asteriskjava.live.AsteriskQueueEntry;
import org.asteriskjava.live.QueueEntryState;
/**
* Default implementation of the AsteriskQueueEntry interface.
*
* @author gmi
*/
class AsteriskQueueEntryImpl extends AbstractLiveObject implements AsteriskQueueEntry
{
private final AsteriskQueueImpl queue;
private final AsteriskChannelImpl channel;
private final Date dateJoined;
private Date dateLeft;
private QueueEntryState state;
// the position as given by asterisk in the queue entry or join event.
// we cannot work reliably with it because asterisk doesn't tell us when it shifts the entries.
private int reportedPosition;
// The position of this entry in our representation of the queue. Will be set
// and maintained by the respective queue when the entry is added/removed/shifted
private int position = POSITION_UNDETERMINED;
AsteriskQueueEntryImpl(AsteriskServerImpl server, AsteriskQueueImpl queue,
AsteriskChannelImpl channel, int reportedPosition, Date dateJoined)
{
super(server);
this.queue = queue;
this.channel = channel;
this.dateJoined = dateJoined;
this.state = QueueEntryState.JOINED;
this.reportedPosition = reportedPosition;
}
public String getChannelName()
{
return channel.getName();
}
public AsteriskQueueImpl getQueue()
{
return queue;
}
public AsteriskChannelImpl getChannel()
{
return channel;
}
public Date getDateJoined()
{
return dateJoined;
}
public Date getDateLeft()
{
return dateLeft;
}
/**
* Sets the status to {@link QueueEntryState#LEFT} and dateLeft to the given date.
*
* @param dateLeft the date this member left the queue.
*/
void left(Date dateLeft)
{
QueueEntryState oldState;
synchronized (this)
{
oldState = this.state;
this.dateLeft = dateLeft;
this.state = QueueEntryState.LEFT;
}
firePropertyChange(PROPERTY_STATE, oldState, state);
}
public QueueEntryState getState()
{
return state;
}
/**
* Gets the position as reported by Asterisk when the entry was created.
* Currently we don't update this property as the entry shifts through the queue,
* see getPosition() instead.
*
* @return the position of the entry in the respective queue, starting at 1
*/
public int getReportedPosition()
{
return reportedPosition;
}
/**
* Gets the position in the queue based on the queue's internal list
* <p/>
* As Asterisk doesn't send events when it shifts entries in the queue
* we'll base our positions on our internal queue entries ordered list.
* It should be coherent as entries are always added at the end of the queue
* and we don't mind if it is different from asterisk's view as long as the
* relative order stays the same. Most of the time the position will be the same
* but right after asterisk removes an entry it could differ as the shift occurs
* asynchronously in asterisk queues. As a consequence we might have temporary holes
* in the asterisk numbering.
*
* @return the position of the entry in the respective queue, starting at 1
*/
public int getPosition()
{
return position;
}
void setPosition(int position)
{
int oldPosition = this.position;
this.position = position;
firePropertyChange(PROPERTY_POSITION, oldPosition, position);
}
void setReportedPosition(int reportedPosition)
{
int oldPosition = this.reportedPosition;
this.reportedPosition = reportedPosition;
firePropertyChange(PROPERTY_REPORTED_POSITION, oldPosition, reportedPosition);
}
@Override
public String toString()
{
StringBuffer sb;
int systemHashcode;
sb = new StringBuffer("AsteriskQueueEntry[");
synchronized (this)
{
sb.append("dateJoined=").append(getDateJoined()).append(",");
sb.append("postition=").append(getPosition()).append(",");
sb.append("dateLeft=").append(getDateLeft()).append(",");
systemHashcode = System.identityHashCode(this);
}
if (channel != null)
{
sb.append("channel=AsteriskChannel[");
synchronized (channel)
{
sb.append("id='").append(channel.getId()).append("',");
sb.append("name='").append(channel.getName()).append("'],");
}
}
else
{
sb.append("channel=null,");
}
sb.append("systemHashcode=").append(systemHashcode);
sb.append("]");
return sb.toString();
}
}