LogReservationCollection.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / WCF / Log / System / IO / Log / LogReservationCollection.cs / 1305376 / LogReservationCollection.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------
namespace System.IO.Log
{ 
    using System;
    using System.IO.Log; 
 
    // NOTE: The reservations in the collection do not account for
    //       header sizes, out of necessity. The reservations made 
    //       with the record sequence *do* account for header sizes.
    //
    //       In order to maintain sanity, the record sequence only
    //       deals with reservations that include the header 
    //       size. i.e., if it goes into CLFS, it has the header size
    //       appended to it. 
    // 
    //       So that means: If we receive a size from the collection,
    //       add the header size to it before returning it. If we 
    //       receive a size from our code, subtract the header size
    //       before giving it to the collection.
    //
    //       Keep this straight, or else. 
    //
    sealed class LogReservationCollection : ReservationCollection 
    { 
        LogRecordSequence recordSequence;
 
        internal LogReservationCollection(LogRecordSequence sequence)
        {
            this.recordSequence = sequence;
        } 

        internal LogRecordSequence RecordSequence 
        { 
            get { return this.recordSequence; }
        } 

        internal long GetMatchingReservation(long size)
        {
            // Reservation coming from CLFS, subtract record header 
            // size.
            // 
            size -= LogLogRecordHeader.Size; 
            size = GetBestMatchingReservation(size);
            if (size == -1) 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ReservationNotFound());

            // Reservation coming from the collection, add record
            // header size. 
            //
            size += LogLogRecordHeader.Size; 
            return size; 
        }
 
        internal void InternalAddReservation(long size)
        {
            // Reservation coming from CLFS, remove record header
            // size. 
            //
            size -= LogLogRecordHeader.Size; 
            ReservationMade(size); 
        }
 
        protected override void MakeReservation(long size)
        {
            if (size < 0)
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ArgumentOutOfRange("size")); 

            // Reservation coming from collection, add record header 
            // size. 
            //
            size += LogLogRecordHeader.Size; 

            long aligned;
            UnsafeNativeMethods.AlignReservedLogSingle(
                this.recordSequence.MarshalContext, 
                size,
                out aligned); 
 
            UnsafeNativeMethods.AllocReservedLog(
                this.recordSequence.MarshalContext, 
                1,
                ref aligned);
        }
 
        protected override void FreeReservation(long size)
        { 
            if (size < 0) 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(Error.ArgumentOutOfRange("size"));
 
            lock(this.recordSequence.LogStore.SyncRoot)
            {
                SafeMarshalContext context = this.recordSequence.InternalMarshalContext ;
 
                if(context == null || context.IsInvalid)
                { 
                    return; 
                }
 
                // Reservation coming from collection, add record header
                // size.
                //
                size += LogLogRecordHeader.Size; 

                long aligned; 
                UnsafeNativeMethods.AlignReservedLogSingle( 
                    context,
                    size, 
                    out aligned);

                // Adjustment must be negative, otherwise it's considered
                // a "set".  (Yuck.) 
                //
                aligned = -aligned; 
                UnsafeNativeMethods.FreeReservedLog( 
                    context,
                    1, 
                    ref aligned);
            }
        }
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK