NH-3345 - Remove support for non generic id-bags

Author: hazzik

src/NHibernate/Bytecode/ICollectionTypeFactory.cs

@@ -57,20 +57,6 @@ public interface ICollectionTypeFactory
 		/// </returns>
 		CollectionType List<T>(string role, string propertyRef, bool embedded);
 
-		/// <summary>
-		/// Creates a new <see cref="CollectionType"/> for an <see cref="IList"/>
-		/// with id-bag semantics.
-		/// </summary>
-		/// <param name="role">The role the collection is in.</param>
-		/// <param name="propertyRef">The name of the property in the
-		/// owner object containing the collection ID, or <see langword="null" /> if it is
-		/// the primary key.</param>
-		/// <param name="embedded">Is embedded in XML (not supported yet)</param>
-		/// <returns>
-		/// A <see cref="IdentifierBagType"/> for the specified role.
-		/// </returns>
-		CollectionType IdBag(string role, string propertyRef, bool embedded);
-
 		/// <summary>
 		/// Creates a new <see cref="CollectionType"/> for an 
 		/// <see cref="System.Collections.Generic.IList{T}"/> with identifier

src/NHibernate/Mapping/IdentifierBag.cs

@@ -10,20 +10,23 @@ namespace NHibernate.Mapping
 	[Serializable]
 	public class IdentifierBag : IdentifierCollection
 	{
-		public IdentifierBag(PersistentClass owner) : base(owner)
+		public IdentifierBag(PersistentClass owner)
+			: base(owner)
 		{
 		}
 
 		public override CollectionType DefaultCollectionType
 		{
 			get
 			{
+				System.Type elementType = typeof(object);
 				if (IsGeneric)
 				{
 					CheckGenericArgumentsLength(1);
-					return TypeFactory.GenericIdBag(Role, ReferencedPropertyName, GenericArguments[0]);
+					elementType = GenericArguments[0];
 				}
-				return TypeFactory.IdBag(Role, ReferencedPropertyName, Embedded);
+
+				return TypeFactory.GenericIdBag(Role, ReferencedPropertyName, elementType);
 			}
 		}
 	}

src/NHibernate/NHibernate.csproj

@@ -665,7 +665,6 @@
     <Compile Include="Type\GuidType.cs" />
     <Compile Include="Type\IAbstractComponentType.cs" />
     <Compile Include="Type\IAssociationType.cs" />
-    <Compile Include="Type\IdentifierBagType.cs" />
     <Compile Include="Type\IDiscriminatorType.cs" />
     <Compile Include="Type\IIdentifierType.cs" />
     <Compile Include="Type\ILiteralType.cs" />

src/NHibernate/Type/DefaultCollectionTypeFactory.cs

@@ -21,11 +21,6 @@ public virtual CollectionType List<T>(string role, string propertyRef, bool embe
 			return new GenericListType<T>(role, propertyRef);
 		}
 
-		public virtual CollectionType IdBag(string role, string propertyRef, bool embedded)
-		{
-			return new IdentifierBagType(role, propertyRef, embedded);
-		}
-
 		public virtual CollectionType IdBag<T>(string role, string propertyRef, bool embedded)
 		{
 			return new GenericIdentifierBagType<T>(role, propertyRef);

src/NHibernate/Type/GenericIdentifierBagType.cs

@@ -7,32 +7,80 @@
 
 namespace NHibernate.Type
 {
+	/// <summary>
+	/// An <see cref="IType"/> that maps an <see cref="IList{T}"/> collection
+	/// using bag semantics with an identifier to the database.
+	/// </summary>
 	[Serializable]
-	public class GenericIdentifierBagType<T> : IdentifierBagType
+	public class GenericIdentifierBagType<T> : CollectionType
 	{
+		/// <summary>
+		/// Initializes a new instance of a <see cref="CollectionType"/> class for
+		/// a specific role.
+		/// </summary>
+		/// <param name="role">The role the persistent collection is in.</param>
+		/// <param name="propertyRef">The name of the property in the
+		/// owner object containing the collection ID, or <see langword="null" /> if it is
+		/// the primary key.</param>
 		public GenericIdentifierBagType(string role, string propertyRef)
 			: base(role, propertyRef, false)
 		{
 		}
 
+		/// <summary>
+		/// Instantiates a new <see cref="IPersistentCollection"/> for the identifier bag.
+		/// </summary>
+		/// <param name="session">The current <see cref="ISessionImplementor"/> for the identifier bag.</param>
+		/// <param name="persister"></param>
+		/// <param name="key"></param>
+		/// <returns></returns>
 		public override IPersistentCollection Instantiate(ISessionImplementor session, ICollectionPersister persister, object key)
 		{
 			return new PersistentIdentifierBag<T>(session);
 		}
 
+		/// <summary>
+		/// Wraps an <see cref="IList{T}"/> in a <see cref="PersistentIdentifierBag{T}"/>.
+		/// </summary>
+		/// <param name="session">The <see cref="ISessionImplementor"/> for the collection to be a part of.</param>
+		/// <param name="collection">The unwrapped <see cref="IList{T}"/>.</param>
+		/// <returns>
+		/// An <see cref="PersistentIdentifierBag{T}"/> that wraps the non NHibernate <see cref="IList{T}"/>.
+		/// </returns>
 		public override IPersistentCollection Wrap(ISessionImplementor session, object collection)
 		{
 			return new PersistentIdentifierBag<T>(session, (ICollection<T>) collection);
 		}
 
+		/// <summary></summary>
 		public override System.Type ReturnedClass
 		{
 			get { return typeof(IList<T>); }
 		}
 
+		/// <summary> 
+		/// Instantiate an empty instance of the "underlying" collection (not a wrapper),
+		/// but with the given anticipated size (i.e. accounting for initial capacity
+		/// and perhaps load factor).
+		/// </summary>
+		/// <param name="anticipatedSize">
+		/// The anticipated size of the instantiated collection after we are done populating it.
+		/// </param>
+		/// <returns> A newly instantiated collection to be wrapped. </returns>
 		public override object Instantiate(int anticipatedSize)
 		{
 			return anticipatedSize <= 0 ? new List<T>() : new List<T>(anticipatedSize + 1);
 		}
+
+
+		protected override void Clear(object collection)
+		{
+			((IList<T>)collection).Clear();
+		}
+
+		protected override void Add(object collection, object element)
+		{
+			((IList<T>)collection).Add((T)element);
+		}
 	}
 }

src/NHibernate/Type/IdentifierBagType.cs

@@ -754,11 +754,6 @@ public static CollectionType Array(string role, string propertyRef, bool embedde
 			return Instance.CollectionTypeFactory.Array(role, propertyRef, embedded, elementClass);
 		}
 
-		public static CollectionType IdBag(string role, string propertyRef, bool embedded)
-		{
-			return Instance.CollectionTypeFactory.IdBag(role, propertyRef, embedded);
-		}
-
 		public static CollectionType Map(string role, string propertyRef, bool embedded)
 		{
 			return Instance.CollectionTypeFactory.Map(role, propertyRef, embedded);