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); } }