public string GetConflictMessage(ConfiguredDataSourceFactory conflictingDataSource) { var lambdasAreTheSame = HasSameDataSourceLambdaAs(conflictingDataSource); var conflictIdentifier = lambdasAreTheSame ? "that" : "a"; return($"{TargetMember.GetPath()} already has {conflictIdentifier} configured data source"); }
public ConfiguredDataSourceFactory CreateReverseIfAppropriate(bool isAutoReversal) { if (CannotBeReversed(out var targetMember, out _)) { return(null); } var reverseConfigInfo = GetReverseConfigInfo(); var sourceParameter = Parameters.Create(reverseConfigInfo.SourceType, "source"); var sourceMemberAccess = TargetMember.GetQualifiedAccess(sourceParameter); var sourceMemberAccessLambda = Expression.Lambda( Expression.GetFuncType(sourceParameter.Type, sourceMemberAccess.Type), sourceMemberAccess, sourceParameter); var sourceMemberLambdaInfo = ConfiguredLambdaInfo.For(sourceMemberAccessLambda); return(new ConfiguredDataSourceFactory(reverseConfigInfo, sourceMemberLambdaInfo, targetMember) { _isReversal = true, WasAutoCreated = isAutoReversal }); }
public override int GetHashCode() { unchecked { return(((TargetMember != null ? TargetMember.GetHashCode() : 0) * 397) ^ (OriginMember != null ? OriginMember.GetHashCode() : 0)); } }
public virtual void Emit(CompilationContext context) { var sourceType = SourceType; var targetType = TargetMember.MemberType; var targetCanWrite = TargetMember.CanWrite(HasOption(MemberMapOptions.NonPublic)); if (targetCanWrite && _converter != null) { EmitSource(context); _converter.Emit(sourceType, targetType, context); EmitSetTarget(context); return; } if (!targetCanWrite && _mapper != null) { EmitSource(context); EmitSetTarget(context); _mapper.Emit(sourceType, targetType, context); return; } if (!HasOption(MemberMapOptions.Hierarchy) || !targetType.GetTypeInfo().IsClass || targetType.IsNullable()) { var converter = GetConvertEmitter(sourceType, targetType); if (converter != null) { EmitSource(context); converter(context); EmitSetTarget(context); } } else { var mapperType = _genericMapperTypes[Triplet.Create(_container, sourceType, targetType)]; if (targetCanWrite) { EmitSource(context); context.CurrentType = sourceType; context.EmitCall(mapperType.GetMethod("Convert")); EmitSetTarget(context); } else { var sourceValue = context.DeclareLocal(sourceType); EmitSource(context); context.Emit(OpCodes.Stloc, sourceValue); var targetValue = context.DeclareLocal(targetType); ((IMemberBuilder)TargetMember).EmitGetter(context); context.Emit(OpCodes.Stloc, targetValue); context.Emit(OpCodes.Ldloc, sourceValue); context.Emit(OpCodes.Ldloc, targetValue); context.EmitCall(mapperType.GetMethod("Map")); } } }
public string GetConflictMessage(ConfiguredDataSourceFactory conflictingDataSource) { if (HasMemberFilter) { return($"Member ignore pattern '{TargetMemberFilter}' conflicts with a configured data source"); } return($"Ignored member {TargetMember.GetPath()} has a configured data source"); }
public string GetConflictMessage(UserConfiguredItemBase conflictingConfiguredItem) { if (conflictingConfiguredItem is ConfiguredDataSourceFactory conflictingDataSource) { return(GetConflictMessage(conflictingDataSource)); } return($"Member {TargetMember.GetPath()} has been ignored"); }
protected override bool TargetMembersAreCompatible(IBasicMapperData mapperData) { if (base.TargetMembersAreCompatible(mapperData)) { return(true); } return(TargetMember.IsRoot && TargetMember.HasCompatibleType(mapperData.TargetMember.Type)); }
private bool IsEntryPoint() { if (IsRoot || Context.IsStandalone) { return(true); } return(TargetMember.IsRecursionRoot()); }
public override void ModifyObj(TObj obj, string FromText) { var regexPattern = GetRegex(); var regex = new Regex(regexPattern); var match = regex.Match(FromText); if (!match.Success) { throw new InvalidOperationException(String.Format("Could not match regex {0} to input {1}", regexPattern, FromText)); } string capture_name = GetEnumerableGroupCaptureName(); var captures = match.Groups[capture_name].Captures.Cast <Capture>(); IList list = ListFactory(); Trace.WriteLine(String.Format("EnumerablePropertyBuilder.GetRegex(): Processing {0}.{1} - begin", this.TargetMember.DeclaringType.Name, this.TargetMember.Name)); foreach (var capture in captures) { object property_value = capture.Value; Trace.WriteLine(String.Format("EnumerablePropertyBuilder.GetRegex(): Processing {0}.{1} - enumerable match {2} - begin", this.TargetMember.DeclaringType.Name, this.TargetMember.Name, capture.Value)); var modifiers = GetModifiers().Reverse().ToArray(); foreach (var modifier in modifiers) { Trace.WriteLine(String.Format("EnumerablePropertyBuilder.GetRegex(): Processing {0}.{1} - enumerable match {2} ({3}) - applying modifier {4}", this.TargetMember.DeclaringType.Name, this.TargetMember.Name, capture.Value, property_value, modifier)); property_value = modifier.ModifyTargetValue(this.Builder, this.UnderlyingElementType, property_value); } Trace.WriteLine(String.Format("EnumerablePropertyBuilder.GetRegex(): Processing {0}.{1} - enumerable match {2} - completed, result {3}", this.TargetMember.DeclaringType.Name, this.TargetMember.Name, capture.Value, property_value)); list.Add(property_value); } if (MinCount != null && list.Count < (int)MinCount) { throw new InvalidOperationException(String.Format("Expected at least {0} items, but found only {1}", (int)MinCount, list.Count)); } if (MaxCount != null && list.Count > (int)MaxCount) { throw new InvalidOperationException(String.Format("Expected at most {0} items, but found {1}", (int)MaxCount, list.Count)); } Trace.WriteLine(String.Format("EnumerablePropertyBuilder.GetRegex(): Processing {0}.{1} - completed", this.TargetMember.DeclaringType.Name, this.TargetMember.Name)); TargetMember.SetValue(obj, list); }
public string GetConflictMessage(UserConfiguredItemBase conflictingConfiguredItem) { switch (conflictingConfiguredItem) { case ConfiguredDataSourceFactory conflictingDataSource: return(GetConflictMessage(conflictingDataSource)); case ConfiguredMemberIgnoreBase conflictingMemberIgnore: return(GetConflictMessage(conflictingMemberIgnore)); default: return($"Member {TargetMember.GetPath()} has been ignored"); } }
public string GetConflictMessage(ConfiguredIgnoredMember conflictingIgnoredMember) { string thisFilter = TargetMemberFilter, thatFilter = null; var matcher = thisFilter ?? (thatFilter = conflictingIgnoredMember.TargetMemberFilter); if (matcher == null) { return($"Member {TargetMember.GetPath()} has already been ignored"); } if (thisFilter == (thatFilter ?? conflictingIgnoredMember.TargetMemberFilter)) { return($"Ignore pattern '{matcher}' has already been configured"); } return($"Member {TargetMember.GetPath()} is already ignored by ignore pattern '{matcher}'"); }
public virtual void ModifyObj(TObj obj, string FromText) { if (String.IsNullOrWhiteSpace(FromText)) { return; } object property_value = FromText; var modifiers = GetModifiers().Reverse(); foreach (var modifier in modifiers) { property_value = modifier.ModifyTargetValue(this.Builder, this.TargetMember.GetUnderlyingType(), property_value); } TargetMember.SetValue(obj, property_value); }
static bool IsMatch(bool isField, bool isProp, bool isPublic, TargetMember targetMembers) { if (isField) { if (isPublic) { if ((targetMembers & TargetMember.PublicFields) != 0) { return(true); } } else { if ((targetMembers & TargetMember.PrivateFields) != 0) { return(true); } } } if (isProp) { if (isPublic) { if ((targetMembers & TargetMember.PublicProperties) != 0) { return(true); } } else { if ((targetMembers & TargetMember.PrivateProperties) != 0) { return(true); } } } return(false); }
public virtual void Emit(CompilationContext context) { var sourceType = SourceType; var targetType = TargetMember.MemberType; var targetCanWrite = TargetMember.CanWrite(HasOption(MemberMapOptions.NonPublic)); if (targetCanWrite && _converter != null) { EmitSource(context); _converter.Emit(sourceType, targetType, context); EmitSetTarget(context); return; } if (!targetCanWrite && _mapper != null) { EmitSource(context); EmitSetTarget(context); _mapper.Emit(sourceType, targetType, context); return; } if (!HasOption(MemberMapOptions.Hierarchy) || #if NETSTANDARD !targetType.GetTypeInfo().IsClass #else !targetType.IsClass #endif || targetType.IsNullable()) { var converter = GetConvertEmitter(sourceType, targetType); if (converter != null) { EmitSource(context); converter(context); EmitSetTarget(context); } }
private string GetTargetMemberPath() => TargetMember.GetFriendlyTargetPath(ConfigInfo);
internal static List <SerializedMember> GetSerializableMembers(Type type, TargetMember defaultTargetMembers, Func <SerializedMember, SerializationOverride> fieldFilter = null) { List <SerializedMember> members = new List <SerializedMember>(); var flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic; var classConfig = type.GetCustomAttribute <MemberConfig>(); foreach (var m in type.GetFields(flags).Cast <MemberInfo>().Concat(type.GetProperties(flags))) { bool isPublic; bool isField = false, isProp = false; if (m is FieldInfo f) { // Skip readonly if (f.IsInitOnly) { continue; } // Skip property backing fields if (f.GetCustomAttribute <CompilerGeneratedAttribute>() != null) { continue; } isPublic = f.IsPublic; isField = true; } else if (m is PropertyInfo p) { if (!p.CanRead || !p.CanWrite) { continue; } if (p.GetIndexParameters().Length != 0) { continue; } isPublic = p.GetMethod.IsPublic; isProp = true; } else { continue; } var serializedMember = FieldOrProp.Create(m); // // 1.) Use filter if there is one if (fieldFilter != null) { var filterResult = fieldFilter(serializedMember); if (filterResult == SerializationOverride.ForceInclude) { members.Add(serializedMember); continue; } else if (filterResult == SerializationOverride.ForceSkip) { continue; } } // // 2.) Use attribute var ignore = m.GetCustomAttribute <Ignore>(true) != null; var include = m.GetCustomAttribute <Include>(true) != null; if (ignore && include) { throw new Exception($"Member '{m.Name}' on type '{type.Name}' has both [Ignore] and [Include]!"); } if (ignore) { continue; } if (include) { members.Add(serializedMember); continue; } // // 3.) Use class attributes if (classConfig != null) { if (IsMatch(isField, isProp, isPublic, classConfig.TargetMembers)) { members.Add(serializedMember); continue; } } // // 4.) Use global defaults if (IsMatch(isField, isProp, isPublic, defaultTargetMembers)) { members.Add(serializedMember); continue; } } members.Sort(_memberComparer); return(members); }
public MemberConfigAttribute(TargetMember targetMembers = TargetMember.PublicFields, ReadonlyFieldHandling readonlyFieldHandling = ReadonlyFieldHandling.ExcludeFromSerialization) { TargetMembers = targetMembers; ReadonlyFieldHandling = readonlyFieldHandling; }
public QualifiedMember GetTargetMemberFor(string targetMemberRegistrationName) => TargetMember.GetChildMember(targetMemberRegistrationName);
public MemberConfig(TargetMember targetMembers = TargetMember.PublicFields, ReadonlyFieldHandling readonlyFieldHandling = ReadonlyFieldHandling.Off) { TargetMembers = targetMembers; ReadonlyFieldHandling = readonlyFieldHandling; }
protected override string GetTargetDescription() => TargetMember.GetFriendlyTargetPath(ConfigInfo);
public string GetConflictMessage(ConfiguredDataSourceFactoryBase conflictingDataSource) => $"Configured dictionary key member {TargetMember.GetPath()} has a configured data source";
public override string GetConflictMessage(ConfiguredDataSourceFactory conflictingDataSource) => $"Ignored member {TargetMember.GetPath()} has a configured data source";
protected override bool TargetMembersAreCompatibleForToTarget(QualifiedMember otherTargetMember) => TargetMember.HasCompatibleType(otherTargetMember.Type);
public MemberConfig(TargetMember targetMembers = TargetMember.PublicFields) { TargetMembers = targetMembers; }