public Boolean TryGetLatest(ChargingReservation_Id Id,
out ChargingReservation LatestReservation)
{
if (InternalData.TryGetValue(Id, out ChargingReservationCollection ReservationCollection))
{
LatestReservation = ReservationCollection.LastOrDefault();
return(true);
}
LatestReservation = null;
return(false);
}
/// <summary>
/// Reserves and appends a set of records.
/// </summary>
/// <param name="sequence">The log record sequence.</param>
/// <param name="data">Byte array segments that will be concatenated and appended as the record.</param>
/// <param name="newBaseSeqNum">The new base sequence number. The specified sequence number must be greater than or equal to the current base sequence number.</param>
/// <param name="reservationCollection">The reservation collection to make reservations in.</param>
/// <returns>The sequence number of the appended log record.</returns>
public static Task <SequenceNumber> WriteRestartArea(
this LogRecordSequence sequence,
IList <ArraySegment <byte> > data,
SequenceNumber newBaseSeqNum,
ReservationCollection reservationCollection)
{
return
(Task.Factory.FromAsync(
(callback, state) =>
((LogRecordSequence)state).BeginWriteRestartArea(
data,
newBaseSeqNum,
reservationCollection,
callback,
state),
sequence.EndWriteRestartArea,
sequence));
}
public static Task <SequenceNumber> AppendAsync(
this LogRecordSequence sequence,
IList <ArraySegment <byte> > data,
SequenceNumber userRecord,
SequenceNumber previousRecord,
RecordAppendOptions recordAppendOptions,
ReservationCollection reservationCollection)
{
return
(Task.Factory.FromAsync(
(callback, state) =>
((LogRecordSequence)state).BeginAppend(
data,
userRecord,
previousRecord,
recordAppendOptions,
reservationCollection,
callback,
state),
sequence.EndAppend,
sequence));
}
public static Task<SequenceNumber> AppendAsync(
this LogRecordSequence sequence,
IList<ArraySegment<byte>> data,
SequenceNumber userRecord,
SequenceNumber previousRecord,
RecordAppendOptions recordAppendOptions,
ReservationCollection reservationCollection)
{
return
Task.Factory.FromAsync(
(callback, state) =>
((LogRecordSequence)state).BeginAppend(
data,
userRecord,
previousRecord,
recordAppendOptions,
reservationCollection,
callback,
state),
sequence.EndAppend,
sequence);
}
public SequenceNumber WriteRestartArea(
IList<ArraySegment<byte>> data,
SequenceNumber newBaseSeqNum,
ReservationCollection reservations)
{
long size = 0;
if (data == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ArgumentNull("data"));
}
if (reservations == null)
return WriteRestartArea(data, newBaseSeqNum);
FileReservationCollection reservationCollection = reservations as FileReservationCollection;
if (reservationCollection == null || !reservationCollection.IsMyCollection(this))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ArgumentInvalid(SR.LogRecSeq_InvalidReservationCollection));
}
for (int i = 0; i < data.Count; i++)
{
size = checked(size + data[i].Count);
}
long reservation = reservationCollection.GetBestMatchingReservation(size);
if (reservation < 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ReservationNotFound());
}
bool throwing = true;
try
{
SequenceNumber returnValue = WriteRestartArea(data, newBaseSeqNum);
throwing = false;
return returnValue;
}
finally
{
if (throwing)
{
reservationCollection.Add(reservation);
}
}
}
public SequenceNumber WriteRestartArea(
ArraySegment<byte> data,
SequenceNumber newBaseSeqNum,
ReservationCollection reservations)
{
return WriteRestartArea(new ArraySegment<byte>[] { data },
newBaseSeqNum,
reservations);
}
public SequenceNumber ReserveAndAppend(
IList<ArraySegment<byte>> data,
SequenceNumber nextUndoRecord,
SequenceNumber previousRecord,
RecordAppendOptions recordAppendOptions,
ReservationCollection reservationCollection,
params long[] reservations)
{
if (reservationCollection == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ArgumentNull("reservationCollection"));
}
if (reservations == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ArgumentNull("reservations"));
}
FileReservationCollection fileResCollection = null;
fileResCollection = reservationCollection as FileReservationCollection;
if (fileResCollection == null || !fileResCollection.IsMyCollection(this))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ArgumentInvalid(SR.LogRecSeq_InvalidReservationCollection));
}
foreach (long reservationSize in reservations)
{
if (reservationSize < 0)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ArgumentOutOfRange("reservations"));
}
foreach (long reservationSize in reservations)
{
fileResCollection.Add(reservationSize);
}
bool throwing = true;
try
{
SequenceNumber returnValue = Append(data, nextUndoRecord, previousRecord, recordAppendOptions);
throwing = false;
return returnValue;
}
finally
{
if (throwing && fileResCollection != null)
{
foreach (long reservationSize in reservations)
{
fileResCollection.Remove(reservationSize);
}
}
}
}
public SequenceNumber ReserveAndAppend(
ArraySegment<byte> data,
SequenceNumber nextUndoRecord,
SequenceNumber previousRecord,
RecordAppendOptions recordAppendOptions,
ReservationCollection reservationCollection,
params long[] reservations)
{
return ReserveAndAppend(new ArraySegment<byte>[] { data },
nextUndoRecord,
previousRecord,
recordAppendOptions,
reservationCollection,
reservations);
}
public IAsyncResult BeginWriteRestartArea(
IList<ArraySegment<byte>> data,
SequenceNumber newBaseSeqNum,
ReservationCollection reservation,
AsyncCallback callback,
object state)
{
SequenceNumber result = WriteRestartArea(data, newBaseSeqNum, reservation);
return new FileRecordSequenceCompletedAsyncResult(result, callback, state, Work.WriteRestartArea);
}
public IAsyncResult BeginWriteRestartArea(
ArraySegment<byte> data,
SequenceNumber newBaseSeqNum,
ReservationCollection reservation,
AsyncCallback callback,
object state)
{
return BeginWriteRestartArea(new ArraySegment<byte>[] { data },
newBaseSeqNum,
reservation,
callback,
state);
}
public IAsyncResult BeginReserveAndAppend(
IList<ArraySegment<byte>> data,
SequenceNumber nextUndoRecord,
SequenceNumber previousRecord,
RecordAppendOptions recordAppendOptions,
ReservationCollection reservationCollection,
long[] reservations,
AsyncCallback callback,
object state)
{
SequenceNumber result = ReserveAndAppend(data,
nextUndoRecord,
previousRecord,
recordAppendOptions,
reservationCollection,
reservations);
return new FileRecordSequenceCompletedAsyncResult(result, callback, state, Work.ReserveAndAppend);
}
public IAsyncResult BeginReserveAndAppend(
ArraySegment<byte> data,
SequenceNumber nextUndoRecord,
SequenceNumber previousRecord,
RecordAppendOptions recordAppendOptions,
ReservationCollection reservationCollection,
long[] reservations,
AsyncCallback callback,
object state)
{
return BeginReserveAndAppend(new ArraySegment<byte>[] { data },
nextUndoRecord,
previousRecord,
recordAppendOptions,
reservationCollection,
reservations,
callback,
state);
}
public SequenceNumber Append(
IList<ArraySegment<byte>> data,
SequenceNumber nextUndoRecord,
SequenceNumber previousRecord,
RecordAppendOptions recordAppendOptions,
ReservationCollection reservations)
{
int size = 0;
if (reservations == null)
{
return Append(data, nextUndoRecord, previousRecord, recordAppendOptions);
}
if (data == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ArgumentNull("data"));
}
FileReservationCollection reservationCollection = reservations as FileReservationCollection;
if (reservationCollection == null || !reservationCollection.IsMyCollection(this))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ArgumentInvalid(SR.LogRecSeq_InvalidReservationCollection));
}
for (int i = 0; i < data.Count; i++)
{
size += data[i].Count;
}
long reservation = reservationCollection.GetBestMatchingReservation(size);
if (reservation < 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ReservationNotFound());
}
bool throwing = true;
try
{
SequenceNumber returnValue = this.Append(data, nextUndoRecord, previousRecord, recordAppendOptions);
throwing = false;
return returnValue;
}
finally
{
if (throwing)
{
reservationCollection.Add(reservation);
}
}
}
/// <summary>
/// Reserves and appends a set of records.
/// </summary>
/// <param name="sequence">The log record sequence.</param>
/// <param name="data">Byte array segments that will be concatenated and appended as the record.</param>
/// <param name="newBaseSeqNum">The new base sequence number. The specified sequence number must be greater than or equal to the current base sequence number.</param>
/// <param name="reservationCollection">The reservation collection to make reservations in.</param>
/// <returns>The sequence number of the appended log record.</returns>
public static Task<SequenceNumber> WriteRestartArea(
this LogRecordSequence sequence,
IList<ArraySegment<byte>> data,
SequenceNumber newBaseSeqNum,
ReservationCollection reservationCollection)
{
return
Task.Factory.FromAsync(
(callback, state) =>
((LogRecordSequence)state).BeginWriteRestartArea(
data,
newBaseSeqNum,
reservationCollection,
callback,
state),
sequence.EndWriteRestartArea,
sequence);
}
