implemented baseoffset for lists

Author: firo222

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

@@ -284,13 +284,26 @@ public void CanSpecifyIndexBaseOffsetAndColumnForList()
                 .ForMapping(map => map.HasMany(x => x.ListOfChildren)
                     .AsList(index =>
                     {
-                        index.Base(1);
+                        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>
@@ -451,6 +447,7 @@
     <Compile Include="Mapping\Builders\FilterBuilder.cs" />
     <Compile Include="Mapping\Builders\IndexBuilder.cs" />
     <Compile Include="Mapping\Builders\KeyBuilder.cs" />
+    <Compile Include="Mapping\Builders\ListIndexBuilder.cs" />
     <Compile Include="Mapping\Builders\ManyToManyBuilder.cs" />
     <Compile Include="Mapping\Builders\ManyToOneBuilder.cs" />
     <Compile Include="Mapping\Builders\MapBuilder.cs" />

src/FluentNHibernate/Mapping/Builders/ListIndexBuilder.cs

@@ -0,0 +1,75 @@
+using System;
+using FluentNHibernate.MappingModel;
+using FluentNHibernate.MappingModel.Collections;
+
+namespace FluentNHibernate.Mapping.Builders
+{
+    public class ListIndexBuilder
+    {
+        readonly IndexMapping mapping;
+        readonly AttributeStore sharedColumnAttributes = new AttributeStore();
+    
+        public ListIndexBuilder(IndexMapping mapping)
+        {
+            this.mapping = mapping;
+            mapping.IsManyToMany = false;
+        }
+
+        /// <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

@@ -181,10 +181,10 @@ public T AsList()
         /// Use a list collection with an index
         /// </summary>
         /// <param name="customIndexMapping">Index mapping</param>
-        public T AsList(Action<IndexBuilder> customIndexMapping)
+        public T AsList(Action<ListIndexBuilder> customIndexMapping)
         {
             collectionBuilder = attrs => new ListMapping(attrs);
-            CreateIndexMapping(customIndexMapping);
+            CreateListIndexMapping(customIndexMapping);
 
             if (indexMapping.Columns.IsEmpty())
                 indexMapping.AddDefaultColumn(new ColumnMapping { Name = "Index" });
@@ -254,6 +254,15 @@ private void CreateIndexMapping(Action<IndexBuilder> customIndex)
                 customIndex(builder);
         }
 
+        private void CreateListIndexMapping(Action<ListIndexBuilder> customIndex)
+        {
+            indexMapping = new IndexMapping();
+            var builder = new ListIndexBuilder(indexMapping);
+
+            if (customIndex != null)
+                customIndex(builder);
+        }
+
         /// <summary>
         /// Map an element/value type
         /// </summary>

src/FluentNHibernate/Mapping/VersionPart.cs

@@ -29,7 +29,7 @@ public VersionPart(Type entity, Member property)
         /// <summary>
         /// Specify if this version is database generated
         /// </summary>
-        public VersionGeneratedBuilder<IVersionMappingProvider> Generated
+        public VersionGeneratedBuilder<VersionPart> Generated
         {
             get { return generated; }
         }

src/FluentNHibernate/MappingModel/Collections/IndexMapping.cs

@@ -50,6 +50,12 @@ public string EntityName
             get { return attributes.Get(x => x.EntityName); }
             set { attributes.Set(x => x.EntityName, value); }
         }
+        
+        public int Offset
+        {
+            get { return attributes.Get(x => x.Offset); }
+            set { attributes.Set(x => x.Offset, value); }
+        }
 
         public bool IsManyToMany { get; set; }
         public Type ContainingEntityType { get; set; }

src/FluentNHibernate/MappingModel/Output/XmlIndexWriter.cs

@@ -30,7 +30,10 @@ public override void ProcessIndex(IndexMapping mapping)
             if (mapping.IsManyToMany)
                 WriteManyToManyIndex(mapping);
             else
-                WriteIndex(mapping);
+                if (mapping.HasValue(x => x.Offset))
+                    WriteListIndex(mapping);
+                else
+                    WriteIndex(mapping);
         }
 
         void WriteIndex(IndexMapping mapping)
@@ -41,6 +44,13 @@ void WriteIndex(IndexMapping mapping)
                 element.WithAtt("type", mapping.Type);
         }
 
+        void WriteListIndex(IndexMapping mapping)
+        {
+            var element = document.AddElement("list-index");
+
+            element.WithAtt("base", mapping.Offset);
+        }
+
         void WriteManyToManyIndex(IndexMapping mapping)
         {
             var element = document.AddElement("index-many-to-many");