Merge branch 'master' of https://github.com/firo222/fluent-nhibernate into firo222-master

Conflicts:
	src/FluentNHibernate/FluentNHibernate.csproj
	src/FluentNHibernate/Mapping/ToManyBase.cs
	src/FluentNHibernate/MappingModel/Collections/IndexMapping.cs
	src/FluentNHibernate/MappingModel/Output/XmlIndexWriter.cs

Author: jagregory

src/FluentNHibernate.Testing/DomainModel/Mapping/OneToManyTester.cs

@@ -270,14 +270,42 @@ public void CanSpecifyIndexColumnAndTypeForList()
         {
             new MappingTester<OneToManyTarget>()
                 .ForMapping(map => map.HasMany(x => x.ListOfChildren)
-                    .AsList(index => index
-                                        .Column("ListIndex")
-                                        .Type<int>()
-                ))
+                    .AsList(index =>
+                    {
+                        index.Column("ListIndex");
+                        index.Type<int>();
+                    }))
                 .Element("class/list/index").HasAttribute("type", typeof(int).AssemblyQualifiedName)
                 .Element("class/list/index/column").HasAttribute("name", "ListIndex");
         }
 
+        [Test]
+        public void CanSpecifyIndexBaseOffsetAndColumnForList()
+        {
+            new MappingTester<OneToManyTarget>()
+                .ForMapping(map => map.HasMany(x => x.ListOfChildren)
+                    .AsList(index =>
+                    {
+                        index.Offset(1);
+                        index.Column("ListIndex");
+                    }))
+                .Element("class/list/list-index").HasAttribute("base", "1")
+                .Element("class/list/list-index/column").HasAttribute("name", "ListIndex");
+        }
+
+        [Test]
+        [ExpectedException(typeof(NotSupportedException))]
+        public void SpecifyingIndexBaseOffsetAndTypeForListThrowsNotSupportedException()
+        {
+            new MappingTester<OneToManyTarget>()
+                .ForMapping(map => map.HasMany(x => x.ListOfChildren)
+                    .AsList(index =>
+                    {
+                        index.Offset(1);
+                        index.Type("ListIndex");
+                    }));
+        }
+
         [Test]
         public void CanSetTableName()
         {

src/FluentNHibernate/FluentNHibernate.csproj

@@ -58,10 +58,6 @@
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="Castle.DynamicProxy2, Version=2.1.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\tools\NHibernate\Castle.DynamicProxy2.dll</HintPath>
-    </Reference>
     <Reference Include="Iesi.Collections, Version=1.0.0.3, Culture=neutral, PublicKeyToken=aa95f207798dfdb4, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\tools\NHibernate\Iesi.Collections.dll</HintPath>
@@ -438,6 +434,7 @@
     <Compile Include="MappingModel\Output\XmlNaturalIdWriter.cs" />
     <Compile Include="Mapping\Access.cs" />
     <Compile Include="Mapping\CollectionTypeResolver.cs" />
+    <Compile Include="Mapping\ListIndexPart.cs" />
     <Compile Include="Mapping\Laziness.cs" />
     <Compile Include="Mapping\MappingProviderStore.cs" />
     <Compile Include="Mapping\MemberAccessResolver.cs" />

src/FluentNHibernate/Mapping/ListIndexPart.cs

@@ -0,0 +1,74 @@
+using System;
+using FluentNHibernate.MappingModel;
+using FluentNHibernate.MappingModel.Collections;
+
+namespace FluentNHibernate.Mapping
+{
+    public class ListIndexPart
+    {
+        readonly IndexMapping mapping;
+        readonly AttributeStore sharedColumnAttributes = new AttributeStore();
+    
+        public ListIndexPart(IndexMapping mapping)
+        {
+            this.mapping = mapping;
+        }
+
+        /// <summary>
+        /// offset added to index in column
+        /// </summary>
+        /// <remarks>mutual exclusive with Type()</remarks>
+        /// <param name="offset">offset</param>
+        public void Offset(int offset)
+        {
+            if (mapping.HasValue(x => x.Type))
+                throw new NotSupportedException("Offset is mutual exclusive with Type()");
+            mapping.Offset = offset;
+        }
+        
+        /// <summary>
+        /// Specifies the column name for the index or key of the dictionary.
+        /// </summary>
+        /// <param name="indexColumnName">Column name</param>
+        public void Column(string indexColumnName)
+        {
+            mapping.AddColumn(new ColumnMapping(sharedColumnAttributes) { Name = indexColumnName });
+        }
+        
+        /// <summary>
+        /// Specifies the type of the index/key column
+        /// </summary>
+        /// <remarks>mutual exclusive with offset</remarks>
+        /// <typeparam name="TIndex">Index type</typeparam>
+        public void Type<TIndex>()
+        {
+            if (mapping.HasValue(x => x.Offset))
+                throw new NotSupportedException("Type() is mutual exclusive with Offset()");
+            mapping.Type = new TypeReference(typeof(TIndex));
+        }
+
+        /// <summary>
+        /// Specifies the type of the index/key column
+        /// </summary>
+        /// <remarks>mutual exclusive with offset</remarks>
+        /// <param name="type">Type</param>
+        public void Type(Type type)
+        {
+            if (mapping.HasValue(x => x.Offset))
+                throw new NotSupportedException("Type() is mutual exclusive with Offset()");
+            mapping.Type = new TypeReference(type);
+        }
+
+        /// <summary>
+        /// Specifies the type of the index/key column
+        /// </summary>
+        /// <remarks>mutual exclusive with offset</remarks>
+        /// <param name="type">Type</param>
+        public void Type(string type)
+        {
+            if (mapping.HasValue(x => x.Offset))
+                throw new NotSupportedException("Type() is mutual exclusive with Offset()");
+            mapping.Type = new TypeReference(type);
+        }
+    }
+}

src/FluentNHibernate/Mapping/ToManyBase.cs

@@ -170,10 +170,10 @@ public T AsList()
         /// Use a list collection with an index
         /// </summary>
         /// <param name="customIndexMapping">Index mapping</param>
-        public T AsList(Action<IndexPart> customIndexMapping)
+        public T AsList(Action<ListIndexPart> customIndexMapping)
         {
             collectionBuilder = attrs => CollectionMapping.List(attrs);
-            CreateIndexMapping(customIndexMapping);
+            CreateListIndexMapping(customIndexMapping);
 
             if (indexMapping.Columns.IsEmpty())
                 indexMapping.AddDefaultColumn(new ColumnMapping { Name = "Index" });
@@ -390,6 +390,15 @@ private void CreateIndexMapping(Action<IndexPart> customIndex)
 #pragma warning restore 612,618
         }
 
+        private void CreateListIndexMapping(Action<ListIndexPart> customIndex)
+        {
+            indexMapping = new IndexMapping();
+            var builder = new ListIndexPart(indexMapping);
+
+            if (customIndex != null)
+                customIndex(builder);
+        }
+
         /// <summary>
         /// Map an element/value type
         /// </summary>

src/FluentNHibernate/MappingModel/Collections/IndexMapping.cs

@@ -33,6 +33,12 @@ public TypeReference Type
             set { attributes.Set(x => x.Type, value); }
         }
 
+        public int Offset
+        {
+            get { return attributes.Get(x => x.Offset); }
+            set { attributes.Set(x => x.Offset, value); }
+        }
+
         public Type ContainingEntityType { get; set; }
 
         public IDefaultableEnumerable<ColumnMapping> Columns

src/FluentNHibernate/MappingModel/Output/XmlIndexWriter.cs

@@ -26,12 +26,27 @@ public override void ProcessIndex(IndexMapping mapping)
         {
             document = new XmlDocument();
 
+            if (mapping.HasValue(x => x.Offset))
+                WriteListIndex(mapping);
+            else
+                WriteIndex(mapping);
+        }
+
+        void WriteIndex(IndexMapping mapping)
+        {
             var element = document.AddElement("index");
 
             if (mapping.HasValue(x => x.Type))
                 element.WithAtt("type", mapping.Type);
         }
 
+        void WriteListIndex(IndexMapping mapping)
+        {
+            var element = document.AddElement("list-index");
+
+            element.WithAtt("base", mapping.Offset);
+        }
+
         public override void Visit(ColumnMapping columnMapping)
         {
             var writer = serviceLocator.GetWriter<ColumnMapping>();