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