Cannot extend unmapped class: Entity
===

I have a base class called Entity:

    public class Entity
    {
        public int Id {get;set;}
    }

Let's say I have a class called Customer:

    public class Customer : Entity
    {
        public string Name {get;set;}
    }


Now, using convention based mapping by code in NHibernate 3.3.1, I try the following:

    public static class DataHelper
    {
        private static HbmMapping GetMappings()
        {
            var mapper = new CustomModelMapper(typeof(Entity));           

            return mapper.CompileMappingFor(
                typeof(DataHelper).Assembly.GetExportedTypes()
                    .Where(x => x.IsSubclassOf(typeof(Entity))));
        }
    }
    
When I try to run my app, I get the error "Cannot extend unmapped class: Entity". I don't want to map the Entity class - it's just a base class for inheriting some common properties. How can I tell NHibernate to ignore the unmapped class? For reference, my CustomModelMapper class is listed below. 

The code for my CustomModelMapper class is listed below for reference    
    
    internal class CustomModelMapper : ConventionModelMapper
    {
        private const int DEFAULT_STRING_LENGTH = 100;
        private Type baseType;

        public CustomModelMapper(Type baseType)
        {
            this.baseType = baseType;
        }

        public CustomModelMapper()
        {
            SetupInspectors();
        }

        protected override void AppendDefaultEvents()
        {
            base.AppendDefaultEvents();
            BeforeMapClass += OnBeforeMapClass;
            BeforeMapProperty += OnBeforeMapProperty;
            BeforeMapManyToOne += OnBeforeMapManyToOne;
            BeforeMapBag += OnBeforeMapBag;
            BeforeMapList += OnBeforeMapList;
            BeforeMapSet += OnBeforeMapSet;
        }

        protected void OnBeforeMapClass(IModelInspector modelInspector, Type type, IClassAttributesMapper classCustomizer)
        {
            classCustomizer.Id(type.GetProperty("Id"), m => m.Generator(Generators.Native));
        }

        protected void OnBeforeMapProperty(IModelInspector modelInspector, PropertyPath member, IPropertyMapper propertyCustomizer)
        {
            if (member.LocalMember.GetPropertyOrFieldType().IsEnum)
            {
                var type = member.LocalMember.GetPropertyOrFieldType();
                var genericType = typeof(EnumStringType<>).MakeGenericType(type);
                propertyCustomizer.Type(genericType, null);
            }

            if (member.LocalMember.GetPropertyOrFieldType() == typeof(string))
                propertyCustomizer.Length(DEFAULT_STRING_LENGTH);
        }

        protected void OnBeforeMapManyToOne(IModelInspector modelInspector, PropertyPath member, IManyToOneMapper propertyCustomizer)
        {
            propertyCustomizer.Cascade(Cascade.All);
            propertyCustomizer.Fetch(FetchKind.Join);
            propertyCustomizer.Lazy(LazyRelation.NoLazy);

            propertyCustomizer.Index(string.Format("IX{0}{1}",
                member.GetContainerEntity(modelInspector).Name,
                member.LocalMember.Name));
        }

        protected void OnBeforeMapBag(IModelInspector modelInspector, PropertyPath member, IBagPropertiesMapper propertyCustomizer)
        {
            propertyCustomizer.Cascade(Cascade.All);
            propertyCustomizer.Lazy(CollectionLazy.Extra);
            propertyCustomizer.Fetch(CollectionFetchMode.Subselect);
        }

        protected void OnBeforeMapList(IModelInspector modelInspector, PropertyPath member, IListPropertiesMapper propertyCustomizer)
        {
            propertyCustomizer.Cascade(Cascade.All);
            propertyCustomizer.Lazy(CollectionLazy.Extra);
            propertyCustomizer.Fetch(CollectionFetchMode.Subselect);
        }

        protected void OnBeforeMapSet(IModelInspector modelInspector, PropertyPath member, ISetPropertiesMapper propertyCustomizer)
        {
            propertyCustomizer.Cascade(Cascade.All);
            propertyCustomizer.Lazy(CollectionLazy.Extra);
            propertyCustomizer.Fetch(CollectionFetchMode.Subselect);
        }

        protected void SetupInspectors()
        {
            IsRootEntity((type, declared) =>
            {
                return baseType.Equals(type.BaseType);
            });

            IsEntity((type, declared) =>
            {
                return baseType.IsAssignableFrom(type) && !type.IsInterface;
            });

            IsVersion((member, declared) =>
            {
                return
                    member.Name == "Version" &&
                    member.MemberType == MemberTypes.Property &&
                    member.GetPropertyOrFieldType() == typeof(int);
            });


            IsBag((member, declared) =>
            {
                if (member.GetPropertyOrFieldType().IsGenericType)
                    return IsGenericType(member, typeof(ICollection<>));

                return false;
            });

            IsList((member, declared) =>
            {
                if (member.GetPropertyOrFieldType().IsGenericType)
                    return IsGenericType(member, typeof(IList<>));

                return false;
            });

            IsSet((member, declared) =>
            {
                if (member.GetPropertyOrFieldType().IsGenericType)
                    return IsGenericType(member, typeof(ICG.ISet<>));

                return false;
            });
        }

        protected static bool IsGenericType(MemberInfo member, Type targetType)
        {
            var type = member.GetPropertyOrFieldType();
            var generics = type.GetGenericInterfaceTypeDefinitions();
            return generics.Contains(targetType);
        }
    }
