/*=========================================================================
        ** Retrieves the value from the specified slot.
        =========================================================================*/
        public Object GetData(LocalDataStoreSlot slot)
        {
            Object o = null;

            // Validate the slot.
            m_Manager.ValidateSlot(slot);

            // Cache the slot index to avoid synchronization issues.
            int slotIdx = slot.Slot;

            if (slotIdx >= 0)
            {
                // Delay expansion of m_DataTable if we can
                if (slotIdx >= m_DataTable.Length)
                    return null;

                // Retrieve the data from the given slot.
                o = m_DataTable[slotIdx];
            }

            // Check if the slot has become invalid.
            if (!slot.IsValid())
                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_SlotHasBeenFreed"));
            return o;
        }

 public LocalDataStoreSlot AllocateDataSlot()
 {
     LocalDataStoreSlot slot2;
     bool lockTaken = false;
     RuntimeHelpers.PrepareConstrainedRegions();
     try
     {
         long num4;
         Monitor.Enter(this, ref lockTaken);
         int length = this.m_SlotInfoTable.Length;
         if (this.m_FirstAvailableSlot >= length)
         {
             int num2;
             if (length < 0x200)
             {
                 num2 = length * 2;
             }
             else
             {
                 num2 = length + 0x80;
             }
             bool[] destinationArray = new bool[num2];
             Array.Copy(this.m_SlotInfoTable, destinationArray, length);
             this.m_SlotInfoTable = destinationArray;
             this.m_FirstAvailableSlot = length;
             length = num2;
         }
         int firstAvailableSlot = this.m_FirstAvailableSlot;
         while (true)
         {
             if (!this.m_SlotInfoTable[firstAvailableSlot])
             {
                 break;
             }
             firstAvailableSlot++;
         }
         this.m_SlotInfoTable[firstAvailableSlot] = true;
         this.m_CookieGenerator = (num4 = this.m_CookieGenerator) + 1L;
         LocalDataStoreSlot slot = new LocalDataStoreSlot(this, firstAvailableSlot, num4);
         firstAvailableSlot++;
         while (firstAvailableSlot < length)
         {
             if (this.m_SlotInfoTable[firstAvailableSlot])
             {
                 break;
             }
             firstAvailableSlot++;
         }
         this.m_FirstAvailableSlot = firstAvailableSlot;
         slot2 = slot;
     }
     finally
     {
         if (lockTaken)
         {
             Monitor.Exit(this);
         }
     }
     return slot2;
 }

		private LocalDataStoreElement PopulateElement(LocalDataStoreSlot slot)
		{
			bool flag = false;
			RuntimeHelpers.PrepareConstrainedRegions();
			LocalDataStoreElement result;
			try
			{
				Monitor.Enter(this.m_Manager, ref flag);
				int slot2 = slot.Slot;
				if (slot2 < 0)
				{
					throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_SlotHasBeenFreed"));
				}
				if (slot2 >= this.m_DataTable.Length)
				{
					int slotTableLength = this.m_Manager.GetSlotTableLength();
					LocalDataStoreElement[] array = new LocalDataStoreElement[slotTableLength];
					Array.Copy(this.m_DataTable, array, this.m_DataTable.Length);
					this.m_DataTable = array;
				}
				if (this.m_DataTable[slot2] == null)
				{
					this.m_DataTable[slot2] = new LocalDataStoreElement(slot.Cookie);
				}
				result = this.m_DataTable[slot2];
			}
			finally
			{
				if (flag)
				{
					Monitor.Exit(this.m_Manager);
				}
			}
			return result;
		}

 public LocalDataStoreSlot AllocateDataSlot()
 {
     LocalDataStoreSlot slot2;
     bool tookLock = false;
     RuntimeHelpers.PrepareConstrainedRegions();
     try
     {
         LocalDataStoreSlot slot;
         int num3;
         Monitor.ReliableEnter(this, ref tookLock);
         int length = this.m_SlotInfoTable.Length;
         if (this.m_FirstAvailableSlot < length)
         {
             slot = new LocalDataStoreSlot(this, this.m_FirstAvailableSlot);
             this.m_SlotInfoTable[this.m_FirstAvailableSlot] = 1;
             int index = this.m_FirstAvailableSlot + 1;
             while (index < length)
             {
                 if ((this.m_SlotInfoTable[index] & 1) == 0)
                 {
                     break;
                 }
                 index++;
             }
             this.m_FirstAvailableSlot = index;
             return slot;
         }
         if (length < 0x200)
         {
             num3 = length * 2;
         }
         else
         {
             num3 = length + 0x80;
         }
         byte[] destinationArray = new byte[num3];
         Array.Copy(this.m_SlotInfoTable, destinationArray, length);
         this.m_SlotInfoTable = destinationArray;
         slot = new LocalDataStoreSlot(this, length);
         this.m_SlotInfoTable[length] = 1;
         this.m_FirstAvailableSlot = length + 1;
         slot2 = slot;
     }
     finally
     {
         if (tookLock)
         {
             Monitor.Exit(this);
         }
     }
     return slot2;
 }

		public void SetData(LocalDataStoreSlot slot, object data)
		{
			this.m_Manager.ValidateSlot(slot);
			int slot2 = slot.Slot;
			if (slot2 >= 0)
			{
				LocalDataStoreElement localDataStoreElement = (slot2 < this.m_DataTable.Length) ? this.m_DataTable[slot2] : null;
				if (localDataStoreElement == null)
				{
					localDataStoreElement = this.PopulateElement(slot);
				}
				if (localDataStoreElement.Cookie == slot.Cookie)
				{
					localDataStoreElement.Value = data;
					return;
				}
			}
			throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_SlotHasBeenFreed"));
		}

		public void TestDatastore ()
		{
			otherCtx = cbo.GetContext ();
			
			slot = Context.AllocateDataSlot ();
			LocalDataStoreSlot namedSlot1 = Context.AllocateNamedDataSlot ("slot1");
			LocalDataStoreSlot namedSlot2 = Context.GetNamedDataSlot ("slot2");
			
			Context.SetData (slot, "data");
			Context.SetData (namedSlot1, "data1");
			Context.SetData (namedSlot2, "data2");
			
			otherCtx.DoCallBack (new CrossContextDelegate (CheckOtherContextDatastore));
			
			Assert.IsTrue (Context.GetData (slot).Equals ("data"), "Wrong data 1");
			Assert.IsTrue (Context.GetData (namedSlot1).Equals ("data1"), "Wrong data 2");
			Assert.IsTrue (Context.GetData (namedSlot2).Equals ("data2"), "Wrong data 3");
			
			try
			{
				namedSlot1 = Context.AllocateNamedDataSlot ("slot1");
				Assert.Fail ("Exception expected");
			}
			catch {}
			
			Context.FreeNamedDataSlot ("slot1");
			Context.FreeNamedDataSlot ("slot2");
			
			try
			{
				namedSlot1 = Context.AllocateNamedDataSlot ("slot1");
			}
			catch 
			{
				Assert.Fail ("Exception not expected");
			}
			
			Context.FreeNamedDataSlot ("slot1");
		}

		public object GetData(LocalDataStoreSlot slot)
		{
			this.m_Manager.ValidateSlot(slot);
			int slot2 = slot.Slot;
			if (slot2 >= 0)
			{
				if (slot2 >= this.m_DataTable.Length)
				{
					return null;
				}
				LocalDataStoreElement localDataStoreElement = this.m_DataTable[slot2];
				if (localDataStoreElement == null)
				{
					return null;
				}
				if (localDataStoreElement.Cookie == slot.Cookie)
				{
					return localDataStoreElement.Value;
				}
			}
			throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_SlotHasBeenFreed"));
		}

 private static void SaveContextToStore(LocalDataStoreSlot storeSlot, CSContext context)
 {
     Thread.SetData(storeSlot, context);
 }

		public void ValidateSlot(LocalDataStoreSlot slot)
		{
			if (slot == null || slot.Manager != this)
			{
				throw new ArgumentException(Environment.GetResourceString("Argument_ALSInvalidSlot"));
			}
		}

        [System.Security.SecuritySafeCritical]  // auto-generated
        private LocalDataStoreElement PopulateElement(LocalDataStoreSlot slot)
        {
            bool tookLock = false;
            RuntimeHelpers.PrepareConstrainedRegions();
            try {
                Monitor.Enter(m_Manager, ref tookLock);

                // Make sure that the slot was not freed in the meantime
                int slotIdx = slot.Slot;
                if (slotIdx < 0)
                    throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_SlotHasBeenFreed"));

                if (slotIdx >= m_DataTable.Length)
                {
                    int capacity = m_Manager.GetSlotTableLength();

                    // Validate that the specified capacity is larger than the current one.
                    Contract.Assert(capacity >= m_DataTable.Length, "LocalDataStore corrupted: capacity >= m_DataTable.Length");

                    // Allocate the new data table.
                    LocalDataStoreElement[] NewDataTable = new LocalDataStoreElement[capacity];

                    // Copy all the objects into the new table.
                    Array.Copy(m_DataTable, NewDataTable, m_DataTable.Length);

                    // Save the new table.
                    m_DataTable = NewDataTable;
                }

                // Validate that there is enough space in the local data store now
                Contract.Assert(slotIdx < m_DataTable.Length, "LocalDataStore corrupted: slotIdx < m_DataTable.Length");

                if (m_DataTable[slotIdx] == null)
                    m_DataTable[slotIdx] = new LocalDataStoreElement(slot.Cookie);

                return m_DataTable[slotIdx];
            }
            finally {
                if (tookLock)
                    Monitor.Exit(m_Manager);
            }
        }

        /*=========================================================================
        ** Sets the data in the specified slot.
        =========================================================================*/
        public void SetData(LocalDataStoreSlot slot, Object data)
        {
            // Validate the slot.
            m_Manager.ValidateSlot(slot);

            // Cache the slot index to avoid synchronization issues.
            int slotIdx = slot.Slot;

            if (slotIdx >= 0)
            {
                LocalDataStoreElement element = (slotIdx < m_DataTable.Length) ? m_DataTable[slotIdx] : null;
                if (element == null)
                {
                    element = PopulateElement(slot);
                }

                // Check that the element is owned by this slot by comparing cookies.
                // This is necesary to avoid resurection race conditions.
                if (element.Cookie == slot.Cookie)
                {
                    // Set the data on the given slot.
                    element.Value = data;
                    return;
                }

                // Fall thru and throw exception
            }

            throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_SlotHasBeenFreed"));
        }

 [System.Security.SecurityCritical]  // auto-generated_required
 public static void SetData(LocalDataStoreSlot slot, Object data)
 {
                 Thread.CurrentContext.MyLocalStore.SetData(slot, data);                    
 }

 [System.Security.SecurityCritical]  // auto-generated_required
 public static Object GetData(LocalDataStoreSlot slot)
 {
     return Thread.CurrentContext.MyLocalStore.GetData(slot);              
 }

 public static void SetData(LocalDataStoreSlot slot, object data)
 {
     LocalDataStore domainLocalStore = GetDomainLocalStore();
     if (domainLocalStore == null)
     {
         domainLocalStore = LocalDataStoreManager.CreateLocalDataStore();
         SetDomainLocalStore(domainLocalStore);
     }
     domainLocalStore.SetData(slot, data);
 }

        /*=========================================================================
        ** Retrieves the value from the specified slot.
        =========================================================================*/
        public Object GetData(LocalDataStoreSlot slot)
        {
            // Validate the slot.
            m_Manager.ValidateSlot(slot);

            // Cache the slot index to avoid synchronization issues.
            int slotIdx = slot.Slot;

            if (slotIdx >= 0)
            {
                // Delay expansion of m_DataTable if we can
                if (slotIdx >= m_DataTable.Length)
                    return null;         
                
                // Retrieve the data from the given slot.
                LocalDataStoreElement element = m_DataTable[slotIdx];

          //Initially we prepopulate the elements to be null.     
          if (element == null)
              return null;

                // Check that the element is owned by this slot by comparing cookies.
                // This is necesary to avoid resurection race conditions.
                if (element.Cookie == slot.Cookie)
                    return element.Value;

                // Fall thru and throw exception
            }
                
            throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_SlotHasBeenFreed"));
        }

		public LocalDataStoreSlot AllocateDataSlot()
		{
			bool flag = false;
			RuntimeHelpers.PrepareConstrainedRegions();
			LocalDataStoreSlot result;
			try
			{
				Monitor.Enter(this, ref flag);
				int num = this.m_SlotInfoTable.Length;
				if (this.m_FirstAvailableSlot >= num)
				{
					int num2;
					if (num < 512)
					{
						num2 = num * 2;
					}
					else
					{
						num2 = num + 128;
					}
					bool[] array = new bool[num2];
					Array.Copy(this.m_SlotInfoTable, array, num);
					this.m_SlotInfoTable = array;
					this.m_FirstAvailableSlot = num;
					num = num2;
				}
				int num3 = this.m_FirstAvailableSlot;
				while (this.m_SlotInfoTable[num3])
				{
					num3++;
				}
				this.m_SlotInfoTable[num3] = true;
				int arg_9A_1 = num3;
				long cookieGenerator;
				this.m_CookieGenerator = checked((cookieGenerator = this.m_CookieGenerator) + 1L);
				LocalDataStoreSlot localDataStoreSlot = new LocalDataStoreSlot(this, arg_9A_1, cookieGenerator);
				num3++;
				while (num3 < num && !this.m_SlotInfoTable[num3])
				{
					num3++;
				}
				this.m_FirstAvailableSlot = num3;
				result = localDataStoreSlot;
			}
			finally
			{
				if (flag)
				{
					Monitor.Exit(this);
				}
			}
			return result;
		}

 public static object GetData(LocalDataStoreSlot slot)
 {
     LocalDataStoreManager.ValidateSlot(slot);
     LocalDataStore domainLocalStore = GetDomainLocalStore();
     if (domainLocalStore == null)
     {
         return null;
     }
     return domainLocalStore.GetData(slot);
 }

 /// <summary>
 /// Static constructor creates a new session factory used by all instances
 /// of this class.
 /// </summary>
 static Repository()
 {
     Configuration cfg = new Configuration();
     cfg.AddAssembly("SFASystem.Domain");
     factory = cfg.BuildSessionFactory();
     mysessions =  Thread.AllocateDataSlot();
 }

        static DatabaseControl()
        {
            //log4net.Config.XmlConfigurator.Configure();

            AutoMappingConfiguration cfg = new AutoMappingConfiguration();

            System.Reflection.Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies().Where(w => w.FullName.Contains("ComprasColetivas.Domain.Model")).ToArray();

            factory = Fluently.Configure()

                .Database(MsSqlConfiguration.MsSql2008.ConnectionString(Properties.Settings.Default.ConnectionStringSQLServer).ShowSql())
                .Mappings(m =>
                {
                    m.AutoMappings.Add(AutoMap.Assemblies(cfg, assemblies).Conventions.Setup(c =>
                    {
                        c.Add<PrimaryKeyConvention>();
                        c.Add<CustomForeignKeyConvention>();
                        c.Add<DefaultStringLengthConvention>();
                        c.Add<TableConvention>();
                        c.Add<EnumMappingConvention>();

                    })
                                                                                                   );
                    m.AutoMappings.ToList()[0].IncludeBase<Pessoa>();
                    m.AutoMappings.ToList()[0].IncludeBase<Pagamento>();

                }).ExposeConfiguration(BuildSchema).BuildSessionFactory();

            mysessions = Thread.AllocateDataSlot();
        }

 public EventProvider(Guid providerGuid)
 {
     this.m_providerId = providerGuid;
     s_returnCodeSlot = Thread.AllocateDataSlot();
     Thread.SetData(s_returnCodeSlot, 0);
     this.EtwRegister();
 }