/// <summary>
        /// Add allocations to the current transaction
        /// </summary>
        /// <param name="fid">
        /// 3-character FID code identifying your merchant activity.  These are assigned by Internal Control.
        /// </param>
        /// <param name="chart">
        /// 1-character chart code of the account to which you want to allocate the credit transaction.
        /// </param>
        /// <param name="account">
        /// 7-character account number to which you want to allocate the credit transaction.
        /// </param>
        /// <param name="subAccount">Optional</param>
        /// <param name="project">Optional</param>
        /// <param name="giftNotificationId">
        /// Used by gift transactions to direct the generated gift document to a particular person.  
        /// If this value is not passed (or is not valid) then the gift document will be generated 
        /// to the inbox of the person set up as the default on the server. 
        /// This value should be the UCD Login ID of the desired recipient in upper case.
        /// </param>
        /// <param name="allocationValue">
        /// The amount or percent to allocate to this allocation
        /// </param>
        /// <param name="allocationType">
        /// The type of allocation -- either percent or $ amount
        /// </param>
        public void AddAllocation(string fid, string chart, string account, string subAccount, string project, string giftNotificationId, double allocationValue, AllocationType allocationType)
        {
            var allocation = new allocRequestTransactionAllocation
                                 {
                                     fid = fid,
                                     chart = chart,
                                     account = account,
                                     subAccount = subAccount,
                                     project = project,
                                     giftNotificationId = giftNotificationId
                                 };

            switch (allocationType)
            {
                case AllocationType.Amount:
                    allocation.amount = allocationValue;
                    allocation.amountSpecified = true;
                    break;
                case AllocationType.Percent:
                    allocation.percent = allocationValue;
                    allocation.percentSpecified = true;
                    break;
                default:
                    throw new ArgumentOutOfRangeException("allocationType");
            }

            //Now we have an allocation, add it to the allocation collection
            Allocations.Add(allocation);
        }

        public void AddHolding(AllocationType allocType, string symbol, decimal price, decimal quanity)
        {
            Holding holding = new Holding(this)
                    {
                        AllocType = allocType,
                        Symbol = symbol,
                        Price = price,
                        Quantity = quanity,
                    };

            m_TotalValue += holding.Value;

            Holdings.Add(holding);
        }

        public int ReadFrom(byte[] buffer, int offset)
        {
            PriorDirectEntries = Utilities.ToUInt32LittleEndian(buffer, offset);
            StrategyType = Utilities.ToUInt16LittleEndian(buffer, offset + 4);
            StrategyParameter = Utilities.ToUInt16LittleEndian(buffer, offset + 6);
            MaxEntries = Utilities.ToUInt16LittleEndian(buffer, offset + 8);
            FileType = (FileType)buffer[offset + 11];
            ParentICBLocation = Utilities.ToStruct<LogicalBlockAddress>(buffer, offset + 12);

            ushort flagsField = Utilities.ToUInt16LittleEndian(buffer, offset + 18);
            AllocationType = (AllocationType)(flagsField & 0x3);
            Flags = (InformationControlBlockFlags)(flagsField & 0xFFFC);

            return 20;
        }

        public void AssignAllocationValue(AllocationType allocationType, int allocationId, string allocationName)
        {
            switch (allocationType)
            {
                case AllocationType.Engagement:
                    this.TimesheetEntrySummaryLineKey.EngagementId = allocationId;
                    break;
                case AllocationType.Project:
                    this.TimesheetEntrySummaryLineKey.ProjectId = allocationId;
                    break;
                case AllocationType.BillingRule:
                    this.TimesheetEntrySummaryLineKey.BillingRuleId = allocationId;
                    break;
                case AllocationType.CostCenter:
                    this.TimesheetEntrySummaryLineKey.CostCenterId = allocationId;
                    break;
                case AllocationType.GeneralLedger:
                    this.TimesheetEntrySummaryLineKey.GeneralLedgerId = allocationId;
                    break;
            }

            var allocationValue = new AllocationValue { AllocationType = allocationType, AllocationId = allocationId, AllocationName = allocationName };
            this.timesheetEntryAllocationSlots[allocationType] = allocationValue;
        }

 /// <summary>
 /// Allocates memory of specified type on the xbox.
 /// </summary>
 /// <param name="type"></param>
 /// <param name="size"></param>
 /// <returns>Allocated address.</returns>
 public uint AllocateMemory(AllocationType type, uint size)
 {
     switch (type)
     {
         case AllocationType.Debug:		return AllocateDebugMemory(size);
         case AllocationType.Physical:	return AllocatePhysicalMemory(size);
         case AllocationType.System:		return AllocateSystemMemory(size);
         case AllocationType.Virtual:	return AllocateVirtualMemory(size);
         default:						throw new Exception("Invalid allocation type.");
     }
 }

 public static extern DWORD_PTR VirtualAllocEx( IntPtr hProcess, DWORD_PTR lpAddress, uint dwSize, AllocationType flAllocationType, MemoryProtection flProtect );

 private static extern IntPtr VirtualAllocEx(
     IntPtr hProcess,
     IntPtr lpAddress,
     IntPtr dwSize,
     AllocationType flAllocationType,
     uint flProtect);

 internal static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr address, UIntPtr size, AllocationType allocationType, MemoryProtect protect);

 internal static extern IntPtr VirtualAllocEx(SafeProcessHandle processHandle, IntPtr address, SizeT size, AllocationType flAllocationType,
     MemoryProtection flProtect);

 static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, IntPtr dwSize, AllocationType flAllocationType, MemoryProtection flProtect);

 public void FillAllocationSlot(AllocationType allocationType, AllocationValue allocationValue)
 {
     this.alloctionSlots[allocationType] = allocationValue;
 }

 public static extern int VirtualAllocEx(IntPtr hProcess, Int32 lpAddress,
    Int32 dwSize, AllocationType flAllocationType, MemoryProtection flProtect);

 public static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, AllocationType flAllocationType, ProtectType flProtect);

 public AllocationEntry(uint address, uint size, AllocationType type)
 {
     Address = address;
     Size = size;
     Type = type;
 }

 internal static extern IntPtr VirtualAllocEx(SafeProcessHandle hProcess, uint dwAddress, int nSize, AllocationType dwAllocationType, MemoryProtection dwProtect);

 public static extern bool VirtualFreeEx(
     IntPtr hProcess,
     IntPtr lpAddress,
     uint dwSize,
     AllocationType dwFreeType);

 public static extern bool VirtualFree(UIntPtr lpAddress, UIntPtr dwSize, AllocationType dwFreeType);

     public static extern IntPtr VirtualAlloc(IntPtr lpAddress, UIntPtr dwSize,
 AllocationType flAllocationType, MemoryProtection flProtect);

 public AllocationInfo(AllocationType type, int size)
 {
     this.type = type;
     this.size = size;
 }

 internal static extern bool VirtualFreeEx(SafeProcessHandle processHandle, IntPtr address, SizeT size, AllocationType flAllocationType);