public MemberSerializer(IMember profile, IMemberAccess access, IReader reader, IWriter writer)
{
Profile = profile;
Access = access;
_reader = reader;
_writer = writer;
}
private IAccessor CreateSetter(IConstructLanguage language, string propertyName, IFieldDeclaration field)
{
string propertyChangedName = language.Name == LanguageNames.CSharp ? "OnPropertyChanged" : "RaisePropertyChangedEvent";
IMethodInvocation onPropertyChanged = language.MethodInvocation(language.None <IExpression>(),
language.Identifier(propertyChangedName),
language.None <ITypeArguments>(),
language.Arguments(
language.Argument(language.StringLiteral(propertyName))));
IMemberAccess fieldUsage = language.MemberAccess(language.None <IExpression>(), field.Identifier);
IExpression valueUsage = language.Expression("value");
IStatement assignment = language.AssignmentStatement(fieldUsage, valueUsage);
IIfStatement ifStatement =
language.IfStatement(
language.BinaryExpression(fieldUsage,
Operator.NotEqual,
valueUsage),
language.Block(assignment, language.ExpressionStatement(onPropertyChanged)));
IAccessor setter = language.Setter(language.Block(ifStatement));
return(setter);
}
private void ReplaceWithStringEmpty(IStringLiteral literal)
{
IMemberAccess isEmpty = literal.Language.MemberAccess(literal.Language.TypeName(literal.Type),
literal.Language.None <IExpression>(),
literal.Language.Identifier("Empty"));
literal.ReplaceWith(isEmpty);
}
IMemberSerializer Content(IAlteration <object> alteration, IMember profile, IMemberAccess access)
{
var body = _content.Get(profile);
var start = new Identity <object>(profile).Adapt();
var writer = Wrap(alteration, access, new Enclosure(start, body));
var result = new MemberSerializer(profile, access, body, writer);
return(result);
}
/// <inheritdoc />
protected override void CloneCore(Cloneable source)
{
DescriptionBase original = source as DescriptionBase;
if (original != null)
{
this.CustomName = original.CustomName;
this.MemberAccess = original.MemberAccess;
this.PropertyName = original.PropertyName;
}
}
IMemberSerializer Content(IMember profile, IMemberAccess access)
{
var identity = new Identity <object>(profile);
var composite = IsMember(profile)
? (IWriter <object>) new MemberPropertyWriter(identity)
: identity;
var start = composite.Adapt();
var body = _content.Get(profile);
var writer = new MemberWriter(access, new Enclosure(start, body));
var result = new MemberSerializer(profile, access, body, writer);
return(result);
}
IMemberSerializer Property(IConverter converter, IMember profile, IMemberAccess access)
{
var alteration = new DelegatedAlteration <object>(access.Get);
var serializer = new ConverterProperty <object>(converter, profile).Adapt();
var member = new MemberSerializer(profile, access, serializer, new MemberWriter(access, serializer));
var runtime = _runtime.Get(profile.Metadata);
var property = (IMemberSerializer) new PropertyMemberSerializer(member);
return(runtime != null
? new RuntimeSerializer(new AlteredSpecification <object>(alteration, runtime),
property, Content(profile, access))
: property);
}
IMemberSerializer Content(IMember profile, IMemberAccess access)
{
var identity = new Identity <object>(profile);
var composite = CollectionItemTypeLocator.Default.Get(profile.MemberType)
?.Name == profile.Name
? (IWriter <object>) new MemberPropertyWriter(identity)
: identity;
var start = composite.Adapt();
var body = _content.Get(profile);
var writer = new MemberWriter(access, new Enclosure(start, body));
var result = new MemberSerializer(profile, access, body, writer);
return(result);
}
private void ResolveMemberAccess()
{
if (this.Host == null)
{
return;
}
if (this.Host.CurrentDataProvider == null ||
this.Host.CurrentDataProvider.FieldDescriptions == null)
{
return;
}
var field = this.Host.CurrentDataProvider.FieldDescriptions.GetFieldDescriptionByMember(this.propertyName);
if (field != null)
{
this.MemberAccess = field as IMemberAccess;
}
}
private bool SetTarget(object value, Flags prevFlags = Flags.None)
{
if (target == value)
{
return(false);
}
ReleaseListenerChanged();
target = value;
if (target != null)
{
Type oldTargetType = targetType;
targetType = target.GetType();
if (targetType != oldTargetType)
{
accessMemberType = AccessMemberType.None;
memberType = null;
access = null;
flags = Flags.None;
if (!targetType.IsValueType)
{
if (first == this || (prevFlags & Flags.ListenerMember) == Flags.ListenerMember)
{
flags |= Flags.AllowListenerMember;
}
}
if (memberName == null)
{
accessMemberType = AccessMemberType.None;
memberType = targetType;
access = new SelfAccess();
flags &= ~Flags.AllowListenerMember;
}
else if (!isIndexer)
{
var property = targetType.GetProperty(memberName);
if (property != null)
{
access = new PropertyAccess(property);
accessMemberType = AccessMemberType.Member;
memberType = property.PropertyType;
}
else
{
var field = targetType.GetField(memberName);
if (field != null)
{
access = new FieldAccess(field);
accessMemberType = AccessMemberType.Member;
memberType = field.FieldType;
}
//else
//{
// throw new Exception("Not Found Member. Type: {0}, Member: {1}".FormatArgs(dataType.FullName, memberName));
//}
}
}
else
{
if (targetType.IsArray)
{
accessMemberType = AccessMemberType.Collection;
memberType = targetType.GetElementType();
access = new ArrayAccess()
{
index = index
};
}
else if (typeof(IList).IsAssignableFrom(targetType))
{
accessMemberType = AccessMemberType.Collection;
if (targetType.IsGenericType)
{
memberType = targetType.GetGenericArguments()[0];
}
else
{
memberType = typeof(object);
}
access = new ListAccess()
{
index = index
};
}
else if (typeof(IEnumerable).IsAssignableFrom(targetType))
{
accessMemberType = AccessMemberType.Collection;
memberType = typeof(object);
access = new IEnumerableAccess()
{
index = index
};
}
else if (typeof(IEnumerator).IsAssignableFrom(targetType))
{
accessMemberType = AccessMemberType.Collection;
memberType = typeof(object);
access = new IEnumeratorAccess()
{
index = index
};
}
}
}
ListenerChanged();
}
else
{
flags = Flags.None;
accessMemberType = AccessMemberType.None;
targetType = null;
access = null;
}
OnMemberValueChanged();
return(true);
}
private void InsertWrappedProperties(IClassDeclaration viewModel, List <IPropertyDeclaration> confirmedPropertiesForWrapping, IFieldDeclaration wrappedClassField, IIdentifier onPropertyChangedIdentifier)
{
IConstructLanguage language = viewModel.Language;
foreach (IPropertyDeclaration property in confirmedPropertiesForWrapping)
{
IMemberAccess propertyMemberAccess = language.MemberAccess(
language.MemberAccess(language.None <IExpression>(), wrappedClassField.Identifier),
property.Identifier);
IAccessor getterOfWrapper = language.None <IAccessor>();
IAccessor propertyGetter = property.Getter();
if (propertyGetter.Exists && IsAccessorVisibleOutsideClass(propertyGetter.Modifiers))
{
getterOfWrapper = language.Getter(
language.Modifiers(propertyGetter.Modifiers.Modifiers),
language.Block(
language.ReturnStatement(propertyMemberAccess)));
}
IAccessor setterOfWrapper = language.None <IAccessor>();
IAccessor propertySetter = property.Setter();
if (propertySetter.Exists && IsAccessorVisibleOutsideClass(propertySetter.Modifiers))
{
IStatement assignment = language.AssignmentStatement(propertyMemberAccess, language.Expression("value"));
IMethodInvocation onPropertyChangedInvocation =
language.MethodInvocation(
language.None <IExpression>(),
onPropertyChangedIdentifier,
language.None <ITypeArguments>(),
language.Arguments(
language.Argument(language.StringLiteral(property.Identifier.Name))));
IIfStatement ifStatement =
language.IfStatement(
language.BinaryExpression(propertyMemberAccess,
Operator.NotEqual,
language.Expression("value")),
language.Block(assignment, language.ExpressionStatement(onPropertyChangedInvocation)));
setterOfWrapper = language.Setter(
language.Modifiers(propertyGetter.Modifiers.Modifiers),
language.Block(ifStatement));
}
if (getterOfWrapper.Exists || setterOfWrapper.Exists)
{
IPropertyDeclaration wrapperProperty = language.Property(
language.None <IDocComment>(),
language.None <IAttributes>(),
property.Modifiers,
property.TypeName,
property.Identifier,
getterOfWrapper,
setterOfWrapper);
viewModel.Insert(wrapperProperty);
}
}
}
public ActivatedMemberAccess(IMemberAccess member, string name)
{
_member = member;
_name = name;
}
public MemberWriter(IMemberAccess access, IWriter <object> writer)
{
_access = access;
_writer = writer;
}
static IWriter Wrap(IMemberAccess access, IWriter <object> writer) => new Writer(access, writer);
static IWriter Wrap(IAlteration <object> alteration, IMemberAccess access, IWriter <object> writer) => new AlteringWriter(alteration, new ConditionalWriter(access, writer));
public RoleRepository(IMemberAccess access, IRoleAccess roleAccess, IMapper <Role> mapper)
{
_access = access;
_roleAccess = roleAccess;
_mapper = mapper;
}
public ReadOnlyCollectionMemberAccess(IMemberAccess access) : base(access) => _access = access;
public MemberAccess(ISpecification <object> specification, IMemberAccess access)
{
_specification = specification;
_access = access;
}
public MemberRepository(IMemberAccess access, IMapper <Member> mapper)
{
_access = access;
_mapper = mapper;
}
public DeferredMemberAssignmentCommand(object instance, IMemberAccess access, ISource <object> source)
{
_instance = instance;
_access = access;
_source = source;
}
public void Assign(IInnerContent contents, IMemberAccess access, object value) => access.Assign(contents.Current, value);
