protected bool IsPropertyResolvable(Type type, IMap <String, IPropertyInfo> propertyMap, String memberName, IEntityMetaData metaData)
{
if (metaData != null && metaData.GetMemberByName(memberName) == null)
{
return(false);
}
if (propertyMap == null)
{
propertyMap = PropertyInfoProvider.GetPropertyMap(type);
}
if (propertyMap.ContainsKey(memberName))
{
return(true);
}
String[] memberPath = memberName.Split("\\.".ToCharArray());
if (memberPath.Length == 0)
{
return(false);
}
IPropertyInfo propertyInfo = propertyMap.Get(memberPath[0]);
if (propertyInfo == null)
{
return(false);
}
String remainingMemberName = memberName.Substring(memberPath[0].Length + 1);
return(IsPropertyResolvable(propertyInfo.PropertyType, null, remainingMemberName, metaData));
}
/// <summary>
/// Creates a new <see cref="MockedServiceProvider"/> whose <see cref="TargetProperty"/>
/// is set to a <see cref="PropertyInfo"/> of the specified type <typeparamref name="T"/>.
/// </summary>
public static MockedServiceProvider CreateForTargetPropertyType <T>()
{
return(new MockedServiceProvider()
{
TargetProperty = PropertyInfoProvider <T> .GetPropertyInfo()
});
}
public void should_throw_for_collection_const_expression()
{
var propertyInfo = new PropertyInfoProvider().GetPropertyInfoFromName("DocumentCollection", typeof(TestDocument));
var sut = new ValueProcessor();
sut.Invoking(x => x.Process("value", propertyInfo.PropertyType))
.Should().Throw <NotImplementedException>();
}
public void should_create_string_const_expression()
{
var value = "Some text";
var propertyInfo = new PropertyInfoProvider().GetPropertyInfoFromName("Text", typeof(TestDocument));
var sut = new ValueProcessor();
var result = sut.Process(value, propertyInfo.PropertyType);
result.Value.Should().Be(value);
}
public IPropertyInfo GetMethodHandle(INotifyPropertyChangedSource obj, String propertyName)
{
IPropertyInfo property = PropertyInfoProvider.GetProperty(obj, propertyName);
if (property != null)
{
return(property);
}
throw new Exception("Property not found: " + obj.GetType().FullName + "." + propertyName);
}
public void should_create_date_const_expression()
{
var value = "2018-05-15";
var propertyInfo = new PropertyInfoProvider().GetPropertyInfoFromName("ADate", typeof(TestDocument));
var sut = new ValueProcessor();
var result = sut.Process(value, propertyInfo.PropertyType);
result.Value.Should().Be(DateTime.Parse(value));
}
protected void HandleMemberMappings(ValueObjectConfig config, IMap <String, IList <XElement> > configDetails, IEntityMetaData metaData)
{
Type entityType = config.EntityType;
Type valueType = config.ValueType;
IMap <String, IPropertyInfo> entityPropertyMap = PropertyInfoProvider.GetPropertyMap(entityType);
IMap <String, IPropertyInfo> valuePropertyMap = PropertyInfoProvider.GetPropertyMap(valueType);
for (int i = memberTagNames.Length; i-- > 0;)
{
String memberTagName = memberTagNames[i].LocalName;
IList <XElement> memberTags = configDetails.Get(memberTagName);
if (memberTags == null)
{
continue;
}
for (int j = memberTags.Count; j-- > 0;)
{
XElement element = memberTags[j];
String memberName = XmlConfigUtil.GetRequiredAttribute(element, XmlConstants.NAME);
if (config.IsIgnoredMember(memberName))
{
continue;
}
if (RuntimeValidationActive && !IsPropertyResolvable(valueType, valuePropertyMap, memberName, null))
{
throw new ArgumentException("Value type property '" + valueType.Name + "." + memberName + "' not found");
}
bool holdsListType = XmlConfigUtil.AttributeIsTrue(element, XmlConstants.LIST_TYPE);
if (holdsListType)
{
config.AddListTypeMember(memberName);
}
String entityMemberName = XmlConfigUtil.GetAttribute(element, XmlConstants.NAME_IN_ENTITY);
if (entityMemberName.Length == 0)
{
entityMemberName = memberName;
}
else
{
config.PutValueObjectMemberName(entityMemberName, memberName);
}
if (RuntimeValidationActive && !IsPropertyResolvable(entityType, entityPropertyMap, entityMemberName, metaData))
{
throw new ArgumentException("Entity type property '" + entityType.Name + "." + entityMemberName
+ "' not found while configuring value type '" + valueType.Name + "'");
}
}
}
}
private ComparisonReducer generateComparisonReducer()
{
var propInfo = new PropertyInfoProvider();
var propExpFac = new PropertyExpressionFactory(propInfo);
return(new ComparisonReducer(
new ComparisonProcessor(),
new PropertyProcessor(propInfo, new PropertyExpressionFactory(propInfo)),
new ValueProcessor(),
new NotNullExpressionProcessor(propExpFac)
));
}
public PropertyInfo[] BuildProperties(Type definingType, Type declaringType)
{
if (_properties == null)
{
EnsurePropertyMap();
}
Debug.Assert(_properties != null);
string signature = "L" + definingType.JavaGetName().Replace('.', '/') + ";";
IProperty[] props = _properties.Get(signature);
if (props == null)
{
return(None);
}
return(PropertyInfoProvider.BuildProperties(definingType, declaringType, props, "get", "set"));
}
public static IEnumerable <MemberInfo> Foreach(
this IEnumerable <MemberInfo> mi,
PropertyInfoProvider propAction,
FieldInfoProvider fieldAction,
MemberInfoProvider action = null)
{
foreach (var m in mi)
{
if (m is PropertyInfo && propAction != null)
{
propAction(m as PropertyInfo);
}
else if (m is FieldInfo && fieldAction != null)
{
fieldAction(m as FieldInfo);
}
if (action != null)
{
action(m);
}
}
return(mi);
}
public PropertyInfo[] GetDeclaredProperties()
{
return(PropertyInfoProvider.GetProperties(GenericsReflection.EnsureTypeDef(this), this));
}
private PropertyProcessor CreatePropertyProcessor()
{
var propInfo = new PropertyInfoProvider();
return(new PropertyProcessor(propInfo, new PropertyExpressionFactory(propInfo)));
}
public override IClassVisitor Extend(IClassVisitor visitor, IBytecodeBehaviorState state, IList <IBytecodeBehavior> remainingPendingBehaviors,
IList <IBytecodeBehavior> cascadePendingBehaviors)
{
Type entityType = EntityUtil.GetEntityType(state.Context);
if (entityType == null)
{
return(visitor);
}
IEntityMetaData metaData = EntityMetaDataProvider.GetMetaData(entityType, true);
if (metaData == null)
{
return(visitor);
}
visitor = new FlattenDebugHierarchyVisitor(visitor, metaData.RelationMembers.Length != 0);
bool addValueHolderContainer;
if (EmbeddedEnhancementHint.HasMemberPath(state.Context))
{
foreach (RelationMember member in metaData.RelationMembers)
{
if (!(member is IEmbeddedMember))
{
continue;
}
Member cMember = ((IEmbeddedMember)member).ChildMember;
MethodPropertyInfo prop = (MethodPropertyInfo)PropertyInfoProvider.GetProperty(cMember.DeclaringType, cMember.Name);
if ((prop.Getter != null && state.HasMethod(new MethodInstance(prop.Getter))) || (prop.Setter != null && state.HasMethod(new MethodInstance(prop.Setter))))
{
// Handle this behavior in the next iteration
cascadePendingBehaviors.Add(this);
return(visitor);
}
}
addValueHolderContainer = false;
}
else
{
foreach (RelationMember member in metaData.RelationMembers)
{
if (member is IEmbeddedMember)
{
continue;
}
MethodPropertyInfo prop = (MethodPropertyInfo)PropertyInfoProvider.GetProperty(member.DeclaringType, member.Name);
if ((prop.Getter != null && state.HasMethod(new MethodInstance(prop.Getter))) || (prop.Setter != null && state.HasMethod(new MethodInstance(prop.Setter))))
{
// Handle this behavior in the next iteration
cascadePendingBehaviors.Add(this);
return(visitor);
}
}
// Add this interface only for real entities, not for embedded types
addValueHolderContainer = true;
visitor = new EntityMetaDataHolderVisitor(visitor, metaData);
}
visitor = new SetCacheModificationMethodCreator(visitor);
cascadePendingBehaviors.Add(WaitForApplyBehavior.Create(BeanContext, delegate(IClassVisitor visitor2, IBytecodeBehaviorState state2, IList <IBytecodeBehavior> remainingPendingBehaviors2,
IList <IBytecodeBehavior> cascadePendingBehaviors2)
{
if (addValueHolderContainer)
{
visitor2 = new InterfaceAdder(visitor2, typeof(IValueHolderContainer));
}
visitor2 = new RelationsGetterVisitor(visitor2, metaData, ValueHolderContainerHelper, PropertyInfoProvider);
return(visitor2);
}));
return(visitor);
}
protected void InitializeValueObjectMapping()
{
Object writeLock = GetWriteLock();
lock (writeLock)
{
this.businessObjectSaveOrder = null;
HashMap <Type, IISet <Type> > boTypeToBeforeBoTypes = new HashMap <Type, IISet <Type> >();
HashMap <Type, IISet <Type> > boTypeToAfterBoTypes = new HashMap <Type, IISet <Type> >();
foreach (Entry <Type, IValueObjectConfig> entry in ValueObjectMap.GetExtensions())
{
IValueObjectConfig voConfig = entry.Value;
Type entityType = voConfig.EntityType;
Type valueType = voConfig.ValueType;
IEntityMetaData metaData = GetMetaData(entityType);
if (metaData == null)
{
// Currently no bo metadata found. We can do nothing here
return;
}
IMap <String, ITypeInfoItem> boNameToVoMember = GetTypeInfoMapForVo(valueType);
foreach (RelationMember boMember in metaData.RelationMembers)
{
String boMemberName = boMember.Name;
String voMemberName = voConfig.GetValueObjectMemberName(boMemberName);
ITypeInfoItem voMember = boNameToVoMember.Get(boMemberName);
if (voConfig.IsIgnoredMember(voMemberName) || voMember == null)
{
continue;
}
Type voMemberRealType = voMember.RealType;
if (voConfig.HoldsListType(voMember.Name))
{
IPropertyInfo[] properties = PropertyInfoProvider.GetProperties(voMemberRealType);
if (properties.Length != 1)
{
throw new ArgumentException("ListTypes must have exactly one property");
}
voMemberRealType = TypeInfoProvider.GetMember(voMemberRealType, properties[0]).RealType;
}
if (!ImmutableTypeSet.IsImmutableType(voMemberRealType))
{
// vo member is either a list or a single direct relation to another VO
// This implies that a potential service can handle both VO types as new objects at once
continue;
}
// vo member only holds a id reference which implies that the related VO has to be persisted first to
// contain an id which can be referred to. But we do NOT know the related VO here, but we know
// the related BO where ALL potential VOs will be derived from:
Type boMemberElementType = boMember.ElementType;
if (Object.Equals(entityType, boMemberElementType))
{
continue;
}
AddBoTypeAfter(entityType, boMemberElementType, boTypeToBeforeBoTypes, boTypeToAfterBoTypes);
AddBoTypeBefore(entityType, boMemberElementType, boTypeToBeforeBoTypes, boTypeToAfterBoTypes);
}
}
List <Type> businessObjectSaveOrder = new List <Type>();
foreach (Type boType in boTypeToBeforeBoTypes.KeySet())
{
// BeforeBoType are types which have to be saved BEFORE saving the boType
bool added = false;
for (int a = 0, size = businessObjectSaveOrder.Count; a < size; a++)
{
Type orderedBoType = businessObjectSaveOrder[a];
// OrderedBoType is the type currently inserted at the correct position in the save order - as far as the keyset
// has been traversed, yet
ISet <Type> typesBeforeOrderedType = boTypeToBeforeBoTypes.Get(orderedBoType);
// typesBeforeOrderedType are types which have to be
bool orderedHasToBeAfterCurrent = typesBeforeOrderedType != null && typesBeforeOrderedType.Contains(boType);
if (!orderedHasToBeAfterCurrent)
{
// our boType has nothing to do with the orderedBoType. So we let is be at it is
continue;
}
businessObjectSaveOrder.Insert(a, boType);
added = true;
break;
}
if (!added)
{
businessObjectSaveOrder.Add(boType);
}
}
foreach (Type boType in boTypeToAfterBoTypes.KeySet())
{
if (boTypeToBeforeBoTypes.ContainsKey(boType))
{
// already handled in the previous loop
continue;
}
bool added = false;
for (int a = businessObjectSaveOrder.Count; a-- > 0;)
{
Type orderedBoType = businessObjectSaveOrder[a];
// OrderedBoType is the type currently inserted at the correct position in the save order - as far as the keyset
// has been traversed, yet
ISet <Type> typesBeforeOrderedType = boTypeToBeforeBoTypes.Get(orderedBoType);
bool orderedHasToBeAfterCurrent = typesBeforeOrderedType != null && typesBeforeOrderedType.Contains(boType);
if (!orderedHasToBeAfterCurrent)
{
// our boType has nothing to do with the orderedBoType. So we let it be as it is
continue;
}
businessObjectSaveOrder.Insert(a, boType);
added = true;
break;
}
if (!added)
{
businessObjectSaveOrder.Add(boType);
}
}
this.businessObjectSaveOrder = businessObjectSaveOrder.ToArray();
}
}
public static IServiceContext CreateBootstrap(IProperties properties, Type[] bootstrapModules, params Object[] bootstrapModuleInstances)
{
if (properties == null)
{
properties = Properties.Application;
}
// create own sub-instance of properties
Properties newProps = new Properties(properties);
ThreadLocalCleanupController threadLocalCleanupController = new ThreadLocalCleanupController();
ConversionHelper conversionHelper = new ConversionHelper();
DelegatingConversionHelper delegatingConversionHelper = new DelegatingConversionHelper();
LinkController linkController = new LinkController();
LoggerHistory loggerHistory = new LoggerHistory();
AccessorTypeProvider accessorTypeProvider = new AccessorTypeProvider();
ExtendableRegistry extendableRegistry = new ExtendableRegistry();
GarbageProxyFactory garbageProxyFactory = new GarbageProxyFactory();
PropertyInfoProvider propertyInfoProvider = new PropertyInfoProvider();
BeanContextInitializer beanContextInitializer = new BeanContextInitializer();
CallingProxyPostProcessor callingProxyPostProcessor = new CallingProxyPostProcessor();
ProxyFactory proxyFactory = new ProxyFactory();
DelegateFactory delegateFactory = new DelegateFactory();
AutoLinkPreProcessor threadLocalCleanupPreProcessor = new AutoLinkPreProcessor();
callingProxyPostProcessor.PropertyInfoProvider = propertyInfoProvider;
delegatingConversionHelper.DefaultConversionHelper = conversionHelper;
linkController.ExtendableRegistry = extendableRegistry;
linkController.Props = newProps;
linkController.ProxyFactory = proxyFactory;
beanContextInitializer.CallingProxyPostProcessor = callingProxyPostProcessor;
beanContextInitializer.ConversionHelper = delegatingConversionHelper;
beanContextInitializer.PropertyInfoProvider = propertyInfoProvider;
garbageProxyFactory.AccessorTypeProvider = accessorTypeProvider;
propertyInfoProvider.AccessorTypeProvider = accessorTypeProvider;
threadLocalCleanupPreProcessor.SetExtendableRegistry(extendableRegistry);
threadLocalCleanupPreProcessor.SetExtendableType(typeof(IThreadLocalCleanupBeanExtendable));
LoggerInstancePreProcessor loggerInstancePreProcessor = new LoggerInstancePreProcessor();
propertyInfoProvider.AfterPropertiesSet();
ScanForLogInstance(loggerInstancePreProcessor, propertyInfoProvider, newProps, accessorTypeProvider);
ScanForLogInstance(loggerInstancePreProcessor, propertyInfoProvider, newProps, callingProxyPostProcessor);
ScanForLogInstance(loggerInstancePreProcessor, propertyInfoProvider, newProps, delegatingConversionHelper);
ScanForLogInstance(loggerInstancePreProcessor, propertyInfoProvider, newProps, extendableRegistry);
ScanForLogInstance(loggerInstancePreProcessor, propertyInfoProvider, newProps, linkController);
ScanForLogInstance(loggerInstancePreProcessor, propertyInfoProvider, newProps, loggerHistory);
ScanForLogInstance(loggerInstancePreProcessor, propertyInfoProvider, newProps, beanContextInitializer);
ScanForLogInstance(loggerInstancePreProcessor, propertyInfoProvider, newProps, propertyInfoProvider);
ScanForLogInstance(loggerInstancePreProcessor, propertyInfoProvider, newProps, threadLocalCleanupController);
ScanForLogInstance(loggerInstancePreProcessor, propertyInfoProvider, newProps, threadLocalCleanupPreProcessor);
accessorTypeProvider.AfterPropertiesSet();
callingProxyPostProcessor.AfterPropertiesSet();
delegatingConversionHelper.AfterPropertiesSet();
extendableRegistry.AfterPropertiesSet();
linkController.AfterPropertiesSet();
loggerHistory.AfterPropertiesSet();
beanContextInitializer.AfterPropertiesSet();
threadLocalCleanupController.AfterPropertiesSet();
threadLocalCleanupPreProcessor.AfterPropertiesSet();
PropertiesPreProcessor propertiesPreProcessor = new PropertiesPreProcessor();
propertiesPreProcessor.ConversionHelper = delegatingConversionHelper;
propertiesPreProcessor.PropertyInfoProvider = propertyInfoProvider;
propertiesPreProcessor.AfterPropertiesSet();
// The DelegatingConversionHelper is functional, but has yet no properties set
propertiesPreProcessor.PreProcessProperties(null, null, newProps, "delegatingConversionHelper", delegatingConversionHelper, typeof(DelegatingConversionHelper), null, EmptySet.Empty <String>(), null);
delegatingConversionHelper.AfterPropertiesSet();
BeanContextFactory parentContextFactory = new BeanContextFactory(linkController, beanContextInitializer, proxyFactory, null, newProps, null);
parentContextFactory.RegisterWithLifecycle(loggerHistory).Autowireable <ILoggerHistory>();
parentContextFactory.RegisterWithLifecycle(proxyFactory).Autowireable <IProxyFactory>();
parentContextFactory.RegisterWithLifecycle(threadLocalCleanupController).Autowireable(typeof(IThreadLocalCleanupController),
typeof(IThreadLocalCleanupBeanExtendable));
parentContextFactory.RegisterExternalBean(delegatingConversionHelper).Autowireable(typeof(IConversionHelper), typeof(IDedicatedConverterExtendable));
parentContextFactory.RegisterWithLifecycle(accessorTypeProvider).Autowireable <IAccessorTypeProvider>();
parentContextFactory.RegisterExternalBean(loggerInstancePreProcessor).Autowireable <ILoggerCache>();
parentContextFactory.RegisterWithLifecycle(extendableRegistry).Autowireable <IExtendableRegistry>();
parentContextFactory.RegisterWithLifecycle(garbageProxyFactory).Autowireable <IGarbageProxyFactory>();
parentContextFactory.RegisterWithLifecycle(callingProxyPostProcessor).Autowireable <CallingProxyPostProcessor>();
parentContextFactory.RegisterWithLifecycle(propertyInfoProvider).Autowireable <IPropertyInfoProvider>();
parentContextFactory.RegisterWithLifecycle(delegateFactory).Autowireable <IDelegateFactory>();
if (bootstrapModules != null)
{
for (int a = 0, size = bootstrapModules.Length; a < size; a++)
{
parentContextFactory.RegisterBean(bootstrapModules[a]);
}
}
if (bootstrapModuleInstances != null)
{
for (int a = 0, size = bootstrapModuleInstances.Length; a < size; a++)
{
parentContextFactory.RegisterExternalBean(bootstrapModuleInstances[a]);
}
}
List <IBeanPreProcessor> preProcessors = new List <IBeanPreProcessor>();
preProcessors.Add(propertiesPreProcessor);
preProcessors.Add(loggerInstancePreProcessor);
preProcessors.Add(threadLocalCleanupPreProcessor);
return(parentContextFactory.Create("bootstrap", null, preProcessors, null));
}
/// <summary>
/// Gets all public properties of this type.
/// </summary>
public PropertyInfo[] GetProperties()
{
return(PropertyInfoProvider.GetProperties(this));
}
public void AddMembers(EntityMetaData metaData, IEntityConfig entityConfig)
{
Type realType = entityConfig.RealType;
ISet <String> memberNamesToIgnore = new HashSet <String>();
ISet <String> explicitBasicMemberNames = new HashSet <String>();
IList <IMemberConfig> embeddedMembers = new List <IMemberConfig>();
IMap <String, IMemberConfig> nameToMemberConfig = new HashMap <String, IMemberConfig>();
IMap <String, IRelationConfig> nameToRelationConfig = new HashMap <String, IRelationConfig>();
IdentityLinkedMap <String, Member> nameToMemberMap = new IdentityLinkedMap <String, Member>();
FillNameCollections(entityConfig, memberNamesToIgnore, explicitBasicMemberNames, embeddedMembers, nameToMemberConfig, nameToRelationConfig);
IdentityLinkedSet <PrimitiveMember> alternateIdMembers = new IdentityLinkedSet <PrimitiveMember>();
IdentityLinkedSet <PrimitiveMember> primitiveMembers = new IdentityLinkedSet <PrimitiveMember>();
IdentityLinkedSet <RelationMember> relationMembers = new IdentityLinkedSet <RelationMember>();
IdentityLinkedSet <Member> notMergeRelevant = new IdentityLinkedSet <Member>();
IdentityLinkedSet <Member> containedInAlternateIdMember = new IdentityLinkedSet <Member>();
IPropertyInfo[] properties = PropertyInfoProvider.GetProperties(realType);
IdentityLinkedMap <String, Member> explicitlyConfiguredMemberNameToMember = new IdentityLinkedMap <String, Member>();
HashMap <String, IOrmConfig> nameToConfigMap = new HashMap <String, IOrmConfig>();
// Resolve members for all explicit configurations - both simple and composite ones, each with embedded
// functionality (dot-member-path)
foreach (IMemberConfig memberConfig in entityConfig.GetMemberConfigIterable())
{
PutNameToConfigMap(memberConfig, nameToConfigMap);
if (memberConfig.Ignore)
{
continue;
}
HandleMemberConfig(metaData, realType, memberConfig, explicitlyConfiguredMemberNameToMember, nameToMemberMap);
}
foreach (IRelationConfig relationConfig in entityConfig.GetRelationConfigIterable())
{
PutNameToConfigMap(relationConfig, nameToConfigMap);
HandleRelationConfig(realType, relationConfig, explicitlyConfiguredMemberNameToMember);
}
PutNameToConfigMap(entityConfig.IdMemberConfig, nameToConfigMap);
PutNameToConfigMap(entityConfig.VersionMemberConfig, nameToConfigMap);
PutNameToConfigMap(entityConfig.CreatedByMemberConfig, nameToConfigMap);
PutNameToConfigMap(entityConfig.CreatedOnMemberConfig, nameToConfigMap);
PutNameToConfigMap(entityConfig.UpdatedByMemberConfig, nameToConfigMap);
PutNameToConfigMap(entityConfig.UpdatedOnMemberConfig, nameToConfigMap);
metaData.IdMember = HandleMemberConfig(metaData, realType, entityConfig.IdMemberConfig, explicitlyConfiguredMemberNameToMember, nameToMemberMap);
metaData.VersionMember = HandleMemberConfig(metaData, realType, entityConfig.VersionMemberConfig, explicitlyConfiguredMemberNameToMember, nameToMemberMap);
metaData.CreatedByMember = HandleMemberConfig(metaData, realType, entityConfig.CreatedByMemberConfig, explicitlyConfiguredMemberNameToMember, nameToMemberMap);
metaData.CreatedOnMember = HandleMemberConfig(metaData, realType, entityConfig.CreatedOnMemberConfig, explicitlyConfiguredMemberNameToMember, nameToMemberMap);
metaData.UpdatedByMember = HandleMemberConfig(metaData, realType, entityConfig.UpdatedByMemberConfig, explicitlyConfiguredMemberNameToMember, nameToMemberMap);
metaData.UpdatedOnMember = HandleMemberConfig(metaData, realType, entityConfig.UpdatedOnMemberConfig, explicitlyConfiguredMemberNameToMember, nameToMemberMap);
IdentityHashSet <Member> idMembers = new IdentityHashSet <Member>();
Member idMember = metaData.IdMember;
if (idMember is CompositeIdMember)
{
idMembers.AddAll(((CompositeIdMember)idMember).Members);
}
else
{
idMembers.Add(idMember);
}
// Handle all explicitly configured members
foreach (Entry <String, Member> entry in explicitlyConfiguredMemberNameToMember)
{
String memberName = entry.Key;
IOrmConfig ormConfig = nameToConfigMap.Get(memberName);
Member member = entry.Value;
if (idMembers.Contains(member))
{
continue;
}
if (ormConfig.ExplicitlyNotMergeRelevant)
{
notMergeRelevant.Add(member);
}
if (ormConfig is IRelationConfig)
{
if (!relationMembers.Add((RelationMember)member))
{
throw new Exception("Member has been registered as relation multiple times: " + member.Name);
}
continue;
}
if (!(ormConfig is IMemberConfig))
{
continue;
}
if (((IMemberConfig)ormConfig).AlternateId)
{
if (!alternateIdMembers.Add((PrimitiveMember)member))
{
throw new Exception("Member has been registered as alternate id multiple times: " + member.Name);
}
if (member is CompositeIdMember)
{
Member[] containedMembers = ((CompositeIdMember)member).Members;
containedInAlternateIdMember.AddAll(containedMembers);
}
}
if (!(member is CompositeIdMember) && metaData.VersionMember != member)
{
// Alternate Ids are normally primitives, too. But Composite Alternate Ids not - only their composite
// items are primitives
primitiveMembers.Add((PrimitiveMember)member);
}
}
IdentityHashSet <String> explicitTypeInfoItems = IdentityHashSet <String> .Create(explicitlyConfiguredMemberNameToMember.Count);
foreach (Entry <String, Member> entry in explicitlyConfiguredMemberNameToMember)
{
Member member = entry.Value;
explicitTypeInfoItems.Add(member.Name);
if (member is IEmbeddedMember)
{
explicitTypeInfoItems.Add(((IEmbeddedMember)member).GetMemberPath()[0].Name);
}
}
// Go through the available members to look for potential auto-mapping (simple, no embedded)
for (int i = 0; i < properties.Length; i++)
{
IPropertyInfo property = properties[i];
String memberName = property.Name;
if (memberNamesToIgnore.Contains(memberName))
{
continue;
}
if (explicitTypeInfoItems.Contains(memberName))
{
// already configured, no auto mapping needed for this member
continue;
}
MethodPropertyInfo mProperty = (MethodPropertyInfo)property;
Type elementType = TypeInfoItemUtil.GetElementTypeUsingReflection(mProperty.Getter.ReturnType, null);
if ((nameToMemberMap.Get(property.Name) is RelationMember) || RelationProvider.IsEntityType(elementType))
{
RelationMember member = GetRelationMember(metaData.EntityType, property, nameToMemberMap);
relationMembers.Add(member);
continue;
}
PrimitiveMember member2 = GetPrimitiveMember(metaData.EntityType, property, nameToMemberMap);
if (metaData.IdMember == null && memberName.Equals(EntityMetaData.DEFAULT_NAME_ID))
{
metaData.IdMember = member2;
continue;
}
if (idMembers.Contains(member2) && !alternateIdMembers.Contains(member2) && !containedInAlternateIdMember.Contains(member2))
{
continue;
}
if (member2.Equals(metaData.IdMember) || member2.Equals(metaData.VersionMember) || member2.Equals(metaData.CreatedByMember) ||
member2.Equals(metaData.CreatedOnMember) || member2.Equals(metaData.UpdatedByMember) || member2.Equals(metaData.UpdatedOnMember))
{
continue;
}
if (metaData.VersionMember == null && memberName.Equals(EntityMetaData.DEFAULT_NAME_VERSION))
{
metaData.VersionMember = member2;
continue;
}
if (metaData.CreatedByMember == null && memberName.Equals(EntityMetaData.DEFAULT_NAME_CREATED_BY))
{
metaData.CreatedByMember = member2;
}
else if (metaData.CreatedOnMember == null && memberName.Equals(EntityMetaData.DEFAULT_NAME_CREATED_ON))
{
metaData.CreatedOnMember = member2;
}
else if (metaData.UpdatedByMember == null && memberName.Equals(EntityMetaData.DEFAULT_NAME_UPDATED_BY))
{
metaData.UpdatedByMember = member2;
}
else if (metaData.UpdatedOnMember == null && memberName.Equals(EntityMetaData.DEFAULT_NAME_UPDATED_ON))
{
metaData.UpdatedOnMember = member2;
}
primitiveMembers.Add(member2);
}
foreach (PrimitiveMember member in primitiveMembers)
{
String memberName = member.Name;
if (explicitBasicMemberNames.Contains(memberName))
{
// Even if the name would match, this member was explicitly configured as "basic"
continue;
}
if (metaData.CreatedByMember == null && memberName.Equals(EntityMetaData.DEFAULT_NAME_CREATED_BY))
{
metaData.CreatedByMember = member;
}
else if (metaData.CreatedOnMember == null && memberName.Equals(EntityMetaData.DEFAULT_NAME_CREATED_ON))
{
metaData.CreatedOnMember = member;
}
else if (metaData.UpdatedByMember == null && memberName.Equals(EntityMetaData.DEFAULT_NAME_UPDATED_BY))
{
metaData.UpdatedByMember = member;
}
else if (metaData.UpdatedOnMember == null && memberName.Equals(EntityMetaData.DEFAULT_NAME_UPDATED_ON))
{
metaData.UpdatedOnMember = member;
}
}
FilterWrongRelationMappings(relationMembers);
// Order of setter calls is important
PrimitiveMember[] primitives = primitiveMembers.ToArray();
PrimitiveMember[] alternateIds = alternateIdMembers.ToArray();
RelationMember[] relations = relationMembers.ToArray();
Array.Sort(primitives);
Array.Sort(alternateIds);
Array.Sort(relations);
metaData.PrimitiveMembers = primitives;
metaData.AlternateIdMembers = alternateIds;
metaData.RelationMembers = relations;
foreach (Member member in notMergeRelevant)
{
metaData.SetMergeRelevant(member, false);
}
if (metaData.IdMember == null)
{
throw new Exception("No ID member could be resolved for entity of type " + metaData.RealType);
}
}
