Menu
▾
▴
[Nhibernate-commit] SF.net SVN: nhibernate:[5651] trunk/nhibernate/src/NHibernate
|
From: <fab...@us...> - 2011-04-10 17:55:11
|
Revision: 5651
http://nhibernate.svn.sourceforge.net/nhibernate/?rev=5651&view=rev
Author: fabiomaulo
Date: 2011-04-10 17:55:04 +0000 (Sun, 10 Apr 2011)
Log Message:
-----------
SimpleModelInspector (only as forward to explicit declaration) with minor refactoring
Modified Paths:
--------------
trunk/nhibernate/src/NHibernate/Mapping/ByCode/ExplicitlyDeclaredModel.cs
trunk/nhibernate/src/NHibernate/Mapping/ByCode/FakeModelExplicitDeclarationsHolder.cs
trunk/nhibernate/src/NHibernate/Mapping/ByCode/IModelExplicitDeclarationsHolder.cs
trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/JoinCustomizer.cs
trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/ExplicitDeclarationsHolder.cs
trunk/nhibernate/src/NHibernate/Mapping/ByCode/ModelExplicitDeclarationsHolderExtensions.cs
trunk/nhibernate/src/NHibernate/NHibernate.csproj
trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/SplitPropertiesRegistrationTests.cs
trunk/nhibernate/src/NHibernate.Test/MappingByCode/ModelExplicitDeclarationsHolderMergeTest.cs
Added Paths:
-----------
trunk/nhibernate/src/NHibernate/Mapping/ByCode/SimpleModelInspector.cs
Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/ExplicitlyDeclaredModel.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/ExplicitlyDeclaredModel.cs 2011-04-10 16:38:24 UTC (rev 5650)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/ExplicitlyDeclaredModel.cs 2011-04-10 17:55:04 UTC (rev 5651)
@@ -382,11 +382,17 @@
persistentMembers.Add(member);
}
- public void AddAsPropertySplit(System.Type propertyContainer, string splitGroupId, MemberInfo member)
+ public void AddAsPropertySplit(SplitDefinition definition)
{
+ if (definition == null)
+ {
+ return;
+ }
/* Note: if the user "jump/exclude" a class and then map the property in two subclasses the usage of GetMemberFromDeclaringType() may cause a problem
for a legal usage... we will see when the case happen */
-
+ System.Type propertyContainer = definition.On;
+ string splitGroupId = definition.GroupId;
+ MemberInfo member = definition.Member;
var memberKey = member.GetMemberFromDeclaringType();
string splitGroup;
if (!memberSplitGroup.TryGetValue(memberKey, out splitGroup))
@@ -395,7 +401,7 @@
memberSplitGroup[memberKey] = splitGroupId;
}
- splitDefinitions.Add(new SplitDefinition(propertyContainer, splitGroup, member));
+ splitDefinitions.Add(definition);
}
private void AddTypeSplits(System.Type propertyContainer, string splitGroupId)
Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/FakeModelExplicitDeclarationsHolder.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/FakeModelExplicitDeclarationsHolder.cs 2011-04-10 16:38:24 UTC (rev 5650)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/FakeModelExplicitDeclarationsHolder.cs 2011-04-10 17:55:04 UTC (rev 5651)
@@ -200,9 +200,8 @@
public void AddAsProperty(MemberInfo member) {}
public void AddAsPersistentMember(MemberInfo member){}
+ public void AddAsPropertySplit(SplitDefinition definition) {}
- public void AddAsPropertySplit(System.Type propertyContainer, string splitGroupId, MemberInfo member) {}
-
#endregion
}
}
\ No newline at end of file
Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/IModelExplicitDeclarationsHolder.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/IModelExplicitDeclarationsHolder.cs 2011-04-10 16:38:24 UTC (rev 5650)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/IModelExplicitDeclarationsHolder.cs 2011-04-10 17:55:04 UTC (rev 5651)
@@ -72,6 +72,6 @@
void AddAsMap(MemberInfo member);
void AddAsProperty(MemberInfo member);
void AddAsPersistentMember(MemberInfo member);
- void AddAsPropertySplit(System.Type propertyContainer, string splitGroupId, MemberInfo member);
+ void AddAsPropertySplit(SplitDefinition definition);
}
}
\ No newline at end of file
Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/JoinCustomizer.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/JoinCustomizer.cs 2011-04-10 16:38:24 UTC (rev 5650)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/CustomizersImpl/JoinCustomizer.cs 2011-04-10 17:55:04 UTC (rev 5651)
@@ -85,90 +85,90 @@
public override void Set<TElement>(Expression<Func<TEntity, IEnumerable<TElement>>> property, Action<ISetPropertiesMapper<TEntity, TElement>> collectionMapping, Action<ICollectionElementRelation<TElement>> mapping)
{
MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
- ExplicitDeclarationsHolder.AddAsPropertySplit(typeof (TEntity), splitGroupId, member);
+ ExplicitDeclarationsHolder.AddAsPropertySplit(new SplitDefinition(typeof (TEntity), splitGroupId, member));
base.Set(property, collectionMapping, mapping);
}
public override void Bag<TElement>(Expression<Func<TEntity, IEnumerable<TElement>>> property, Action<IBagPropertiesMapper<TEntity, TElement>> collectionMapping, Action<ICollectionElementRelation<TElement>> mapping)
{
MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
- ExplicitDeclarationsHolder.AddAsPropertySplit(typeof (TEntity), splitGroupId, member);
+ ExplicitDeclarationsHolder.AddAsPropertySplit(new SplitDefinition(typeof(TEntity), splitGroupId, member));
base.Bag(property, collectionMapping, mapping);
}
public override void List<TElement>(Expression<Func<TEntity, IEnumerable<TElement>>> property, Action<IListPropertiesMapper<TEntity, TElement>> collectionMapping, Action<ICollectionElementRelation<TElement>> mapping)
{
MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
- ExplicitDeclarationsHolder.AddAsPropertySplit(typeof (TEntity), splitGroupId, member);
+ ExplicitDeclarationsHolder.AddAsPropertySplit(new SplitDefinition(typeof(TEntity), splitGroupId, member));
base.List(property, collectionMapping, mapping);
}
public override void Map<TKey, TElement>(Expression<Func<TEntity, IDictionary<TKey, TElement>>> property, Action<IMapPropertiesMapper<TEntity, TKey, TElement>> collectionMapping, Action<IMapKeyRelation<TKey>> keyMapping, Action<ICollectionElementRelation<TElement>> mapping)
{
MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
- ExplicitDeclarationsHolder.AddAsPropertySplit(typeof (TEntity), splitGroupId, member);
+ ExplicitDeclarationsHolder.AddAsPropertySplit(new SplitDefinition(typeof(TEntity), splitGroupId, member));
base.Map(property, collectionMapping, keyMapping, mapping);
}
public override void Map<TKey, TElement>(Expression<Func<TEntity, IDictionary<TKey, TElement>>> property, Action<IMapPropertiesMapper<TEntity, TKey, TElement>> collectionMapping, Action<ICollectionElementRelation<TElement>> mapping)
{
MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
- ExplicitDeclarationsHolder.AddAsPropertySplit(typeof (TEntity), splitGroupId, member);
+ ExplicitDeclarationsHolder.AddAsPropertySplit(new SplitDefinition(typeof(TEntity), splitGroupId, member));
base.Map(property, collectionMapping, mapping);
}
public override void Property<TProperty>(Expression<Func<TEntity, TProperty>> property)
{
MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
- ExplicitDeclarationsHolder.AddAsPropertySplit(typeof (TEntity), splitGroupId, member);
+ ExplicitDeclarationsHolder.AddAsPropertySplit(new SplitDefinition(typeof(TEntity), splitGroupId, member));
base.Property(property);
}
public override void Property<TProperty>(Expression<Func<TEntity, TProperty>> property, Action<IPropertyMapper> mapping)
{
MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
- ExplicitDeclarationsHolder.AddAsPropertySplit(typeof (TEntity), splitGroupId, member);
+ ExplicitDeclarationsHolder.AddAsPropertySplit(new SplitDefinition(typeof(TEntity), splitGroupId, member));
base.Property(property, mapping);
}
public override void Property(FieldInfo member, Action<IPropertyMapper> mapping)
{
- ExplicitDeclarationsHolder.AddAsPropertySplit(typeof (TEntity), splitGroupId, member);
+ ExplicitDeclarationsHolder.AddAsPropertySplit(new SplitDefinition(typeof(TEntity), splitGroupId, member));
base.Property(member, mapping);
}
public override void Component<TComponent>(Expression<Func<TEntity, TComponent>> property, Action<IComponentMapper<TComponent>> mapping)
{
MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
- ExplicitDeclarationsHolder.AddAsPropertySplit(typeof (TEntity), splitGroupId, member);
+ ExplicitDeclarationsHolder.AddAsPropertySplit(new SplitDefinition(typeof(TEntity), splitGroupId, member));
base.Component(property, mapping);
}
public override void ManyToOne<TProperty>(Expression<Func<TEntity, TProperty>> property, Action<IManyToOneMapper> mapping)
{
MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
- ExplicitDeclarationsHolder.AddAsPropertySplit(typeof (TEntity), splitGroupId, member);
+ ExplicitDeclarationsHolder.AddAsPropertySplit(new SplitDefinition(typeof(TEntity), splitGroupId, member));
base.ManyToOne(property, mapping);
}
public override void ManyToOne<TProperty>(Expression<Func<TEntity, TProperty>> property)
{
MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
- ExplicitDeclarationsHolder.AddAsPropertySplit(typeof (TEntity), splitGroupId, member);
+ ExplicitDeclarationsHolder.AddAsPropertySplit(new SplitDefinition(typeof(TEntity), splitGroupId, member));
base.ManyToOne(property);
}
public override void Any<TProperty>(Expression<Func<TEntity, TProperty>> property, System.Type idTypeOfMetaType, Action<IAnyMapper> mapping)
{
MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
- ExplicitDeclarationsHolder.AddAsPropertySplit(typeof (TEntity), splitGroupId, member);
+ ExplicitDeclarationsHolder.AddAsPropertySplit(new SplitDefinition(typeof(TEntity), splitGroupId, member));
base.Any(property, idTypeOfMetaType, mapping);
}
public override void IdBag<TElement>(Expression<Func<TEntity, IEnumerable<TElement>>> property, Action<IIdBagPropertiesMapper<TEntity, TElement>> collectionMapping, Action<ICollectionElementRelation<TElement>> mapping)
{
MemberInfo member = TypeExtensions.DecodeMemberAccessExpression(property);
- ExplicitDeclarationsHolder.AddAsPropertySplit(typeof(TEntity), splitGroupId, member);
+ ExplicitDeclarationsHolder.AddAsPropertySplit(new SplitDefinition(typeof(TEntity), splitGroupId, member));
base.IdBag(property, collectionMapping, mapping);
}
}
Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/ExplicitDeclarationsHolder.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/ExplicitDeclarationsHolder.cs 2011-04-10 16:38:24 UTC (rev 5650)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/Impl/ExplicitDeclarationsHolder.cs 2011-04-10 17:55:04 UTC (rev 5651)
@@ -257,9 +257,9 @@
persistentMembers.Add(member);
}
- public void AddAsPropertySplit(System.Type propertyContainer, string splitGroupId, MemberInfo member)
+ public void AddAsPropertySplit(SplitDefinition definition)
{
- splitDefinitions.Add(new SplitDefinition(propertyContainer, splitGroupId, member));
+ splitDefinitions.Add(definition);
}
#endregion
Modified: trunk/nhibernate/src/NHibernate/Mapping/ByCode/ModelExplicitDeclarationsHolderExtensions.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/ModelExplicitDeclarationsHolderExtensions.cs 2011-04-10 16:38:24 UTC (rev 5650)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/ModelExplicitDeclarationsHolderExtensions.cs 2011-04-10 17:55:04 UTC (rev 5651)
@@ -35,7 +35,7 @@
System.Array.ForEach(source.Dictionaries.ToArray(), destination.AddAsMap);
System.Array.ForEach(source.Properties.ToArray(), destination.AddAsProperty);
System.Array.ForEach(source.PersistentMembers.ToArray(), destination.AddAsPersistentMember);
- System.Array.ForEach(source.SplitDefinitions.ToArray(), x => destination.AddAsPropertySplit(x.On, x.GroupId, x.Member));
+ System.Array.ForEach(source.SplitDefinitions.ToArray(), destination.AddAsPropertySplit);
}
}
}
\ No newline at end of file
Added: trunk/nhibernate/src/NHibernate/Mapping/ByCode/SimpleModelInspector.cs
===================================================================
--- trunk/nhibernate/src/NHibernate/Mapping/ByCode/SimpleModelInspector.cs (rev 0)
+++ trunk/nhibernate/src/NHibernate/Mapping/ByCode/SimpleModelInspector.cs 2011-04-10 17:55:04 UTC (rev 5651)
@@ -0,0 +1,640 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+namespace NHibernate.Mapping.ByCode
+{
+ /// <summary>
+ /// A <see cref="IModelInspector"/> which allows customization of conditions with explicitly declared members.
+ /// </summary>
+ public class SimpleModelInspector : IModelInspector, IModelExplicitDeclarationsHolder
+ {
+ private readonly ExplicitlyDeclaredModel declaredModel = new ExplicitlyDeclaredModel();
+
+ private Func<System.Type, bool, bool> isEntity = (t, declared) => declared;
+ private Func<System.Type, bool, bool> isRootEntity = (t, declared) => declared;
+ private Func<System.Type, bool, bool> isTablePerClass = (t, declared) => declared;
+ private Func<SplitDefinition, bool, bool> isTablePerClassSplit = (sd, declared) => declared;
+ private Func<System.Type, bool, bool> isTablePerClassHierarchy = (t, declared) => declared;
+ private Func<System.Type, bool, bool> isTablePerConcreteClass = (t, declared) => declared;
+ private Func<System.Type, IEnumerable<string>, IEnumerable<string>> splitsForType = (t, declared) => declared;
+ private Func<System.Type, bool, bool> isComponent = (t, declared) => declared;
+
+ private Func<MemberInfo, bool, bool> isPersistentId = (m, declared) => declared;
+ private Func<MemberInfo, bool, bool> isPersistentProperty = (m, declared) => declared;
+ private Func<MemberInfo, bool, bool> isVersion = (m, declared) => declared;
+
+ private Func<MemberInfo, bool, bool> isProperty = (m, declared) => declared;
+ private Func<MemberInfo, bool, bool> isAny = (m, declared) => declared;
+ private Func<MemberInfo, bool, bool> isManyToMany = (m, declared) => declared;
+ private Func<MemberInfo, bool, bool> isManyToOne = (m, declared) => declared;
+ private Func<MemberInfo, bool, bool> isMemberOfNaturalId = (m, declared) => declared;
+ private Func<MemberInfo, bool, bool> isOneToMany = (m, declared) => declared;
+ private Func<MemberInfo, bool, bool> isOneToOne = (m, declared) => declared;
+
+ private Func<MemberInfo, bool, bool> isSet = (m, declared) => declared;
+ private Func<MemberInfo, bool, bool> isArray = (m, declared) => declared;
+ private Func<MemberInfo, bool, bool> isBag = (m, declared) => declared;
+ private Func<MemberInfo, bool, bool> isDictionary = (m, declared) => declared;
+ private Func<MemberInfo, bool, bool> isIdBag = (m, declared) => declared;
+ private Func<MemberInfo, bool, bool> isList = (m, declared) => declared;
+
+ #region IModelExplicitDeclarationsHolder Members
+
+ IEnumerable<System.Type> IModelExplicitDeclarationsHolder.RootEntities
+ {
+ get { return declaredModel.RootEntities; }
+ }
+
+ IEnumerable<System.Type> IModelExplicitDeclarationsHolder.Components
+ {
+ get { return declaredModel.Components; }
+ }
+
+ IEnumerable<System.Type> IModelExplicitDeclarationsHolder.TablePerClassEntities
+ {
+ get { return declaredModel.TablePerClassEntities; }
+ }
+
+ IEnumerable<System.Type> IModelExplicitDeclarationsHolder.TablePerClassHierarchyEntities
+ {
+ get { return declaredModel.TablePerClassHierarchyEntities; }
+ }
+
+ IEnumerable<System.Type> IModelExplicitDeclarationsHolder.TablePerConcreteClassEntities
+ {
+ get { return declaredModel.TablePerConcreteClassEntities; }
+ }
+
+ IEnumerable<MemberInfo> IModelExplicitDeclarationsHolder.OneToOneRelations
+ {
+ get { return declaredModel.OneToOneRelations; }
+ }
+
+ IEnumerable<MemberInfo> IModelExplicitDeclarationsHolder.ManyToOneRelations
+ {
+ get { return declaredModel.ManyToManyRelations; }
+ }
+
+ IEnumerable<MemberInfo> IModelExplicitDeclarationsHolder.ManyToManyRelations
+ {
+ get { return declaredModel.ManyToManyRelations; }
+ }
+
+ IEnumerable<MemberInfo> IModelExplicitDeclarationsHolder.OneToManyRelations
+ {
+ get { return declaredModel.OneToManyRelations; }
+ }
+
+ IEnumerable<MemberInfo> IModelExplicitDeclarationsHolder.Any
+ {
+ get { return declaredModel.Any; }
+ }
+
+ IEnumerable<MemberInfo> IModelExplicitDeclarationsHolder.Poids
+ {
+ get { return declaredModel.Poids; }
+ }
+
+ IEnumerable<MemberInfo> IModelExplicitDeclarationsHolder.VersionProperties
+ {
+ get { return declaredModel.VersionProperties; }
+ }
+
+ IEnumerable<MemberInfo> IModelExplicitDeclarationsHolder.NaturalIds
+ {
+ get { return declaredModel.NaturalIds; }
+ }
+
+ IEnumerable<MemberInfo> IModelExplicitDeclarationsHolder.Sets
+ {
+ get { return declaredModel.Sets; }
+ }
+
+ IEnumerable<MemberInfo> IModelExplicitDeclarationsHolder.Bags
+ {
+ get { return declaredModel.Bags; }
+ }
+
+ IEnumerable<MemberInfo> IModelExplicitDeclarationsHolder.IdBags
+ {
+ get { return declaredModel.IdBags; }
+ }
+
+ IEnumerable<MemberInfo> IModelExplicitDeclarationsHolder.Lists
+ {
+ get { return declaredModel.Lists; }
+ }
+
+ IEnumerable<MemberInfo> IModelExplicitDeclarationsHolder.Arrays
+ {
+ get { return declaredModel.Arrays; }
+ }
+
+ IEnumerable<MemberInfo> IModelExplicitDeclarationsHolder.Dictionaries
+ {
+ get { return declaredModel.Dictionaries; }
+ }
+
+ IEnumerable<MemberInfo> IModelExplicitDeclarationsHolder.Properties
+ {
+ get { return declaredModel.Properties; }
+ }
+
+ IEnumerable<MemberInfo> IModelExplicitDeclarationsHolder.PersistentMembers
+ {
+ get { return declaredModel.PersistentMembers; }
+ }
+
+ IEnumerable<SplitDefinition> IModelExplicitDeclarationsHolder.SplitDefinitions
+ {
+ get { return declaredModel.SplitDefinitions; }
+ }
+
+ IEnumerable<string> IModelExplicitDeclarationsHolder.GetSplitGroupsFor(System.Type type)
+ {
+ return declaredModel.GetSplitGroupsFor(type);
+ }
+
+ string IModelExplicitDeclarationsHolder.GetSplitGroupFor(MemberInfo member)
+ {
+ return declaredModel.GetSplitGroupFor(member);
+ }
+
+ void IModelExplicitDeclarationsHolder.AddAsRootEntity(System.Type type)
+ {
+ declaredModel.AddAsRootEntity(type);
+ }
+
+ void IModelExplicitDeclarationsHolder.AddAsComponent(System.Type type)
+ {
+ declaredModel.AddAsComponent(type);
+ }
+
+ void IModelExplicitDeclarationsHolder.AddAsTablePerClassEntity(System.Type type)
+ {
+ declaredModel.AddAsTablePerClassEntity(type);
+ }
+
+ void IModelExplicitDeclarationsHolder.AddAsTablePerClassHierarchyEntity(System.Type type)
+ {
+ declaredModel.AddAsTablePerClassHierarchyEntity(type);
+ }
+
+ void IModelExplicitDeclarationsHolder.AddAsTablePerConcreteClassEntity(System.Type type)
+ {
+ declaredModel.AddAsTablePerConcreteClassEntity(type);
+ }
+
+ void IModelExplicitDeclarationsHolder.AddAsOneToOneRelation(MemberInfo member)
+ {
+ declaredModel.AddAsOneToOneRelation(member);
+ }
+
+ void IModelExplicitDeclarationsHolder.AddAsManyToOneRelation(MemberInfo member)
+ {
+ declaredModel.AddAsManyToOneRelation(member);
+ }
+
+ void IModelExplicitDeclarationsHolder.AddAsManyToManyRelation(MemberInfo member)
+ {
+ declaredModel.AddAsManyToManyRelation(member);
+ }
+
+ void IModelExplicitDeclarationsHolder.AddAsOneToManyRelation(MemberInfo member)
+ {
+ declaredModel.AddAsOneToManyRelation(member);
+ }
+
+ void IModelExplicitDeclarationsHolder.AddAsAny(MemberInfo member)
+ {
+ declaredModel.AddAsAny(member);
+ }
+
+ void IModelExplicitDeclarationsHolder.AddAsPoid(MemberInfo member)
+ {
+ declaredModel.AddAsPoid(member);
+ }
+
+ void IModelExplicitDeclarationsHolder.AddAsVersionProperty(MemberInfo member)
+ {
+ declaredModel.AddAsVersionProperty(member);
+ }
+
+ void IModelExplicitDeclarationsHolder.AddAsNaturalId(MemberInfo member)
+ {
+ declaredModel.AddAsNaturalId(member);
+ }
+
+ void IModelExplicitDeclarationsHolder.AddAsSet(MemberInfo member)
+ {
+ declaredModel.AddAsSet(member);
+ }
+
+ void IModelExplicitDeclarationsHolder.AddAsBag(MemberInfo member)
+ {
+ declaredModel.AddAsBag(member);
+ }
+
+ void IModelExplicitDeclarationsHolder.AddAsIdBag(MemberInfo member)
+ {
+ declaredModel.AddAsIdBag(member);
+ }
+
+ void IModelExplicitDeclarationsHolder.AddAsList(MemberInfo member)
+ {
+ declaredModel.AddAsList(member);
+ }
+
+ void IModelExplicitDeclarationsHolder.AddAsArray(MemberInfo member)
+ {
+ declaredModel.AddAsArray(member);
+ }
+
+ void IModelExplicitDeclarationsHolder.AddAsMap(MemberInfo member)
+ {
+ declaredModel.AddAsMap(member);
+ }
+
+ void IModelExplicitDeclarationsHolder.AddAsProperty(MemberInfo member)
+ {
+ declaredModel.AddAsProperty(member);
+ }
+
+ void IModelExplicitDeclarationsHolder.AddAsPersistentMember(MemberInfo member)
+ {
+ declaredModel.AddAsPersistentMember(member);
+ }
+
+ void IModelExplicitDeclarationsHolder.AddAsPropertySplit(SplitDefinition definition)
+ {
+ declaredModel.AddAsPropertySplit(definition);
+ }
+
+ #endregion
+
+ #region Implementation of IModelInspector
+
+ bool IModelInspector.IsRootEntity(System.Type type)
+ {
+ bool declaredResult = declaredModel.IsRootEntity(type);
+ return isRootEntity(type, declaredResult);
+ }
+
+ bool IModelInspector.IsComponent(System.Type type)
+ {
+ bool declaredResult = declaredModel.IsComponent(type);
+ return isComponent(type, declaredResult);
+ }
+
+ bool IModelInspector.IsEntity(System.Type type)
+ {
+ bool declaredResult = declaredModel.IsEntity(type);
+ return isEntity(type, declaredResult);
+ }
+
+ bool IModelInspector.IsTablePerClass(System.Type type)
+ {
+ bool declaredResult = declaredModel.IsTablePerClass(type);
+ return isTablePerClass(type, declaredResult);
+ }
+
+ bool IModelInspector.IsTablePerClassSplit(System.Type type, object splitGroupId, MemberInfo member)
+ {
+ bool declaredResult = declaredModel.IsTablePerClassSplit(type, splitGroupId, member);
+ return isTablePerClassSplit(new SplitDefinition(type, splitGroupId.ToString(), member), declaredResult);
+ }
+
+ bool IModelInspector.IsTablePerClassHierarchy(System.Type type)
+ {
+ bool declaredResult = declaredModel.IsTablePerClassHierarchy(type);
+ return isTablePerClassHierarchy(type, declaredResult);
+ }
+
+ bool IModelInspector.IsTablePerConcreteClass(System.Type type)
+ {
+ bool declaredResult = declaredModel.IsTablePerConcreteClass(type);
+ return isTablePerConcreteClass(type, declaredResult);
+ }
+
+ bool IModelInspector.IsOneToOne(MemberInfo member)
+ {
+ bool declaredResult = declaredModel.IsOneToOne(member);
+ return isOneToOne(member, declaredResult);
+ }
+
+ bool IModelInspector.IsManyToOne(MemberInfo member)
+ {
+ bool declaredResult = declaredModel.IsManyToOne(member);
+ return isManyToOne(member, declaredResult);
+ }
+
+ bool IModelInspector.IsManyToMany(MemberInfo member)
+ {
+ bool declaredResult = declaredModel.IsManyToMany(member);
+ return isManyToMany(member, declaredResult);
+ }
+
+ bool IModelInspector.IsOneToMany(MemberInfo member)
+ {
+ bool declaredResult = declaredModel.IsOneToMany(member);
+ return isOneToMany(member, declaredResult);
+ }
+
+ bool IModelInspector.IsAny(MemberInfo member)
+ {
+ bool declaredResult = declaredModel.IsAny(member);
+ return isAny(member, declaredResult);
+ }
+
+ bool IModelInspector.IsPersistentId(MemberInfo member)
+ {
+ bool declaredResult = declaredModel.IsPersistentId(member);
+ return isPersistentId(member, declaredResult);
+ }
+
+ bool IModelInspector.IsVersion(MemberInfo member)
+ {
+ bool declaredResult = declaredModel.IsVersion(member);
+ return isVersion(member, declaredResult);
+ }
+
+ bool IModelInspector.IsMemberOfNaturalId(MemberInfo member)
+ {
+ bool declaredResult = declaredModel.IsMemberOfNaturalId(member);
+ return isMemberOfNaturalId(member, declaredResult);
+ }
+
+ bool IModelInspector.IsPersistentProperty(MemberInfo member)
+ {
+ bool declaredResult = declaredModel.IsPersistentProperty(member);
+ return isPersistentProperty(member, declaredResult);
+ }
+
+ bool IModelInspector.IsSet(MemberInfo role)
+ {
+ bool declaredResult = declaredModel.IsSet(role);
+ return isSet(role, declaredResult);
+ }
+
+ bool IModelInspector.IsBag(MemberInfo role)
+ {
+ bool declaredResult = declaredModel.IsBag(role);
+ return isBag(role, declaredResult);
+ }
+
+ bool IModelInspector.IsIdBag(MemberInfo role)
+ {
+ bool declaredResult = declaredModel.IsIdBag(role);
+ return isIdBag(role, declaredResult);
+ }
+
+ bool IModelInspector.IsList(MemberInfo role)
+ {
+ bool declaredResult = declaredModel.IsList(role);
+ return isList(role, declaredResult);
+ }
+
+ bool IModelInspector.IsArray(MemberInfo role)
+ {
+ bool declaredResult = declaredModel.IsArray(role);
+ return isArray(role, declaredResult);
+ }
+
+ bool IModelInspector.IsDictionary(MemberInfo role)
+ {
+ bool declaredResult = declaredModel.IsDictionary(role);
+ return isDictionary(role, declaredResult);
+ }
+
+ bool IModelInspector.IsProperty(MemberInfo member)
+ {
+ bool declaredResult = declaredModel.IsProperty(member);
+ return isProperty(member, declaredResult);
+ }
+
+ IEnumerable<string> IModelInspector.GetPropertiesSplits(System.Type type)
+ {
+ IEnumerable<string> declaredResult = declaredModel.GetPropertiesSplits(type);
+ return splitsForType(type, declaredResult);
+ }
+
+ #endregion
+
+ public void IsRootEntity(Func<System.Type, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isRootEntity = match;
+ }
+
+ public void IsComponent(Func<System.Type, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isComponent = match;
+ }
+
+ public void IsEntity(Func<System.Type, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isEntity = match;
+ }
+
+ public void IsTablePerClass(Func<System.Type, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isTablePerClass = match;
+ }
+
+ public void IsTablePerClassHierarchy(Func<System.Type, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isTablePerClassHierarchy = match;
+ }
+
+ public void IsTablePerConcreteClass(Func<System.Type, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isTablePerConcreteClass = match;
+ }
+
+ public void IsOneToOne(Func<MemberInfo, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isOneToOne = match;
+ }
+
+ public void IsManyToOne(Func<MemberInfo, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isManyToOne = match;
+ }
+
+ public void IsManyToMany(Func<MemberInfo, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isManyToMany = match;
+ }
+
+ public void IsOneToMany(Func<MemberInfo, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isOneToMany = match;
+ }
+
+ public void IsAny(Func<MemberInfo, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isAny = match;
+ }
+
+ public void IsPersistentId(Func<MemberInfo, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isPersistentId = match;
+ }
+
+ public void IsVersion(Func<MemberInfo, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isVersion = match;
+ }
+
+ public void IsMemberOfNaturalId(Func<MemberInfo, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isMemberOfNaturalId = match;
+ }
+
+ public void IsPersistentProperty(Func<MemberInfo, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isPersistentProperty = match;
+ }
+
+ public void IsSet(Func<MemberInfo, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isSet = match;
+ }
+
+ public void IsBag(Func<MemberInfo, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isBag = match;
+ }
+
+ public void IsIdBag(Func<MemberInfo, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isIdBag = match;
+ }
+
+ public void IsList(Func<MemberInfo, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isList = match;
+ }
+
+ public void IsArray(Func<MemberInfo, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isArray = match;
+ }
+
+ public void IsDictionary(Func<MemberInfo, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isDictionary = match;
+ }
+
+ public void IsProperty(Func<MemberInfo, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isProperty = match;
+ }
+
+ public void SplitsFor(Func<System.Type, IEnumerable<string>, IEnumerable<string>> getPropertiesSplitsId)
+ {
+ if (getPropertiesSplitsId == null)
+ {
+ return;
+ }
+ splitsForType = getPropertiesSplitsId;
+ }
+
+ public void IsTablePerClassSplit(Func<SplitDefinition, bool, bool> match)
+ {
+ if (match == null)
+ {
+ return;
+ }
+ isTablePerClassSplit = match;
+ }
+ }
+}
\ No newline at end of file
Modified: trunk/nhibernate/src/NHibernate/NHibernate.csproj
===================================================================
--- trunk/nhibernate/src/NHibernate/NHibernate.csproj 2011-04-10 16:38:24 UTC (rev 5650)
+++ trunk/nhibernate/src/NHibernate/NHibernate.csproj 2011-04-10 17:55:04 UTC (rev 5651)
@@ -290,6 +290,7 @@
<Compile Include="Mapping\ByCode\Conformist\JoinedSubclassMapping.cs" />
<Compile Include="Mapping\ByCode\Conformist\SubclassMapping.cs" />
<Compile Include="Mapping\ByCode\Conformist\UnionSubclassMapping.cs" />
+ <Compile Include="Mapping\ByCode\SimpleModelInspector.cs" />
<Compile Include="Mapping\ByCode\ExplicitlyDeclaredModel.cs" />
<Compile Include="Mapping\ByCode\FakeModelExplicitDeclarationsHolder.cs" />
<Compile Include="Mapping\ByCode\FetchKind.cs" />
Modified: trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/SplitPropertiesRegistrationTests.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/SplitPropertiesRegistrationTests.cs 2011-04-10 16:38:24 UTC (rev 5650)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/ExplicitlyDeclaredModelTests/SplitPropertiesRegistrationTests.cs 2011-04-10 17:55:04 UTC (rev 5651)
@@ -20,8 +20,8 @@
public void WhenRegisterPropertySplitsThenTypeHasSplitGroups()
{
var inspector = new ExplicitlyDeclaredModel();
- inspector.AddAsPropertySplit(typeof(MyClass), "group", For<MyClass>.Property(x => x.Something));
- inspector.AddAsPropertySplit(typeof(Inherited), "group1", For<Inherited>.Property(x => x.SomethingElse));
+ inspector.AddAsPropertySplit(new SplitDefinition(typeof(MyClass), "group", For<MyClass>.Property(x => x.Something)));
+ inspector.AddAsPropertySplit(new SplitDefinition(typeof(Inherited), "group1", For<Inherited>.Property(x => x.SomethingElse)));
inspector.GetSplitGroupsFor(typeof(MyClass)).Should().Have.SameValuesAs("group");
inspector.GetSplitGroupsFor(typeof(Inherited)).Should().Have.SameValuesAs("group1");
@@ -34,8 +34,8 @@
var memberFromDeclaringType = For<MyClass>.Property(x=> x.Something);
var memberFromReferencedType = typeof(Inherited).GetProperty("Something");
- inspector.AddAsPropertySplit(typeof(MyClass), "group", memberFromDeclaringType);
- inspector.AddAsPropertySplit(typeof(Inherited), "group1", memberFromReferencedType);
+ inspector.AddAsPropertySplit(new SplitDefinition(typeof(MyClass), "group", memberFromDeclaringType));
+ inspector.AddAsPropertySplit(new SplitDefinition(typeof(Inherited), "group1", memberFromReferencedType));
inspector.GetSplitGroupsFor(typeof(MyClass)).Should().Have.SameValuesAs("group");
inspector.GetSplitGroupsFor(typeof(Inherited)).Should().Be.Empty();
Modified: trunk/nhibernate/src/NHibernate.Test/MappingByCode/ModelExplicitDeclarationsHolderMergeTest.cs
===================================================================
--- trunk/nhibernate/src/NHibernate.Test/MappingByCode/ModelExplicitDeclarationsHolderMergeTest.cs 2011-04-10 16:38:24 UTC (rev 5650)
+++ trunk/nhibernate/src/NHibernate.Test/MappingByCode/ModelExplicitDeclarationsHolderMergeTest.cs 2011-04-10 17:55:04 UTC (rev 5651)
@@ -22,7 +22,7 @@
{
var destination = new ExplicitDeclarationsHolder();
var source = new ExplicitDeclarationsHolder();
- source.AddAsPropertySplit(typeof (MyClass), "foo", property);
+ source.AddAsPropertySplit(new SplitDefinition(typeof (MyClass), "foo", property));
destination.Merge(source);
destination.SplitDefinitions.Should().Have.Count.EqualTo(1);
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
