internal override void ReadField(ByteBuffer buffer, int index, byte formatCode)
{
switch (index)
{
case 0:
this.role = Encoder.ReadBoolean(buffer, formatCode);
break;
case 1:
this.first = Encoder.ReadUInt(buffer, formatCode);
break;
case 2:
this.last = Encoder.ReadUInt(buffer, formatCode);
break;
case 3:
this.settled = Encoder.ReadBoolean(buffer, formatCode);
break;
case 4:
this.state = (DeliveryState)Encoder.ReadObject(buffer, formatCode);
break;
case 5:
this.batchable = Encoder.ReadBoolean(buffer, formatCode);
break;
default:
Fx.Assert(false, "Invalid field index");
break;
}
}
internal override void ReadField(ByteBuffer buffer, int index, byte formatCode)
{
switch (index)
{
case 0:
this.handle = Encoder.ReadUInt(buffer, formatCode);
break;
case 1:
this.deliveryId = Encoder.ReadUInt(buffer, formatCode);
break;
case 2:
this.deliveryTag = Encoder.ReadBinary(buffer, formatCode);
break;
case 3:
this.messageFormat = Encoder.ReadUInt(buffer, formatCode);
break;
case 4:
this.settled = Encoder.ReadBoolean(buffer, formatCode);
break;
case 5:
this.more = Encoder.ReadBoolean(buffer, formatCode);
break;
case 6:
this.rcvSettleMode = (ReceiverSettleMode)Encoder.ReadUByte(buffer, formatCode);
break;
case 7:
this.state = (DeliveryState)Encoder.ReadObject(buffer, formatCode);
break;
case 8:
this.resume = Encoder.ReadBoolean(buffer, formatCode);
break;
case 9:
this.aborted = Encoder.ReadBoolean(buffer, formatCode);
break;
case 10:
this.batchable = Encoder.ReadBoolean(buffer, formatCode);
break;
default:
Fx.Assert(false, "Invalid field index");
break;
}
}
/// <summary>
/// Sends a disposition for the message.
/// </summary>
/// <param name="message">The message to be disposed (a disposition performative will be sent for this message).</param>
/// <param name="deliveryState">The delivery state to set on disposition.</param>
/// <param name="settled">The settled flag on disposition.</param>
public void DisposeMessage(Message message, DeliveryState deliveryState, bool settled)
{
if (settled && this.autoRestore)
{
lock (this.ThisLock)
{
if (this.restored++ >= this.credit / 2)
{
this.restored = 0;
this.SendFlow(this.deliveryCount, this.credit, false);
}
}
}
Delivery delivery = message.Delivery;
if (delivery == null || delivery.Settled)
{
return;
}
this.Session.DisposeDelivery(this.role, delivery, deliveryState, settled);
}
public void OnStateChange(DeliveryState state)
{
this.State = state;
this.Link.OnDeliveryStateChanged(this);
}
internal void DisposeDelivery(bool role, Delivery delivery, DeliveryState state, bool settled)
{
Delivery current = null;
lock (this.ThisLock)
{
LinkedList deliveryList = role ? this.incomingList : this.outgoingList;
current = (Delivery)deliveryList.First;
while (current != null)
{
if (current == delivery)
{
if (settled)
{
deliveryList.Remove(current);
}
break;
}
current = (Delivery)current.Next;
}
}
if (current != null)
{
current.Settled = settled;
current.State = state;
Dispose dispose = new Dispose()
{
Role = role,
First = current.DeliveryId,
Settled = settled,
State = state
};
this.SendCommand(dispose);
}
}
/// <summary>
/// Disposes the request. If required, a disposition frame is sent to
/// the peer to acknowledge the message.
/// </summary>
/// <param name="deliveryState">The delivery state to send.</param>
protected void Dispose(DeliveryState deliveryState)
{
this.Link.DisposeMessage(this.Message, deliveryState, true);
this.state = ContextState.Completed;
}
internal void Send(Message message, DeliveryState deliveryState, OutcomeCallback callback, object state)
{
const int reservedBytes = 40;
#if NETFX || NETFX40 || DOTNET
var buffer = message.Encode(this.Session.Connection.BufferManager, reservedBytes);
#else
var buffer = message.Encode(reservedBytes);
#endif
if (buffer.Length < 1)
{
throw new ArgumentException("Cannot send an empty message.");
}
Delivery delivery = new Delivery()
{
Message = message,
Buffer = buffer,
ReservedBufferSize = reservedBytes,
State = deliveryState,
Link = this,
OnOutcome = callback,
UserToken = state,
Settled = this.settleMode == SenderSettleMode.Settled || callback == null
};
lock (this.ThisLock)
{
this.ThrowIfDetaching("Send");
if (this.credit <= 0 || this.writing)
{
this.outgoingList.Add(delivery);
return;
}
delivery.Tag = Delivery.GetDeliveryTag(this.deliveryCount);
this.credit--;
this.deliveryCount++;
this.writing = true;
}
this.WriteDelivery(delivery);
}
internal void Send(Message message, DeliveryState deliveryState, OutcomeCallback callback, object state)
{
var buffer = message.Encode();
if (buffer.Length < 1)
{
throw new ArgumentException("Cannot send an empty message.");
}
Delivery delivery = new Delivery()
{
Message = message,
Buffer = buffer,
State = deliveryState,
Link = this,
OnOutcome = callback,
UserToken = state,
Settled = this.settleMode == SenderSettleMode.Settled || callback == null
};
lock (this.ThisLock)
{
this.ThrowIfDetaching("Send");
if (this.credit <= 0 || this.writing)
{
this.outgoingList.Add(delivery);
return;
}
delivery.Tag = GetDeliveryTag(this.deliveryCount);
this.credit--;
this.deliveryCount++;
this.writing = true;
}
this.WriteDelivery(delivery);
}
internal DispositionContext(ListenerLink link, Message message, DeliveryState deliveryState, bool settled)
: base(link, message)
{
this.Settled = settled;
}
/// <summary>
/// Sends a disposition for the message.
/// </summary>
/// <param name="message">The message to be disposed (a disposition performative will be sent for this message).</param>
/// <param name="deliveryState">The delivery state to set on disposition.</param>
/// <param name="settled">The settled flag on disposition.</param>
public void DisposeMessage(Message message, DeliveryState deliveryState, bool settled)
{
Delivery delivery = message.Delivery;
if (delivery == null || delivery.Settled)
{
return;
}
this.Session.DisposeDelivery(this.role, delivery, deliveryState, settled);
}
/// <summary>
/// Disposes the request. If required, a disposition frame is sent to
/// the peer to acknowledge the message.
/// </summary>
/// <param name="deliveryState">The delivery state to send.</param>
protected void Dispose(DeliveryState deliveryState)
{
this.Link.DisposeMessage(this.Message, deliveryState, true);
}
