/// <summary> /// Set weave result /// </summary> /// <param name="result">Result</param> public void SetWeaveResult(WeaveResult result) { _weaveResult = result; }
private WeaveResult WeaveProperty(PropertyDefinition prop, TypeDefinition type, Dictionary <string, Tuple <MethodReference, MethodReference> > methodTable) { var columnName = prop.Name; var mapToAttribute = prop.CustomAttributes.FirstOrDefault(a => a.AttributeType.Name == "MapToAttribute"); if (mapToAttribute != null) { columnName = (string)mapToAttribute.ConstructorArguments[0].Value; } var backingField = prop.GetBackingField(); var isIndexed = prop.CustomAttributes.Any(a => a.AttributeType.Name == "IndexedAttribute"); if (isIndexed && (!_indexableTypes.Contains(prop.PropertyType.FullName))) { return(WeaveResult.Error($"{type.Name}.{prop.Name} is marked as [Indexed] which is only allowed on integral types as well as string, bool and DateTimeOffset, not on {prop.PropertyType.FullName}.")); } var isPrimaryKey = prop.CustomAttributes.Any(a => a.AttributeType.Name == "PrimaryKeyAttribute"); if (isPrimaryKey && (!_primaryKeyTypes.Contains(prop.PropertyType.FullName))) { return(WeaveResult.Error($"{type.Name}.{prop.Name} is marked as [PrimaryKey] which is only allowed on integral and string types, not on {prop.PropertyType.FullName}.")); } if (!prop.IsAutomatic()) { if (prop.PropertyType.Resolve().BaseType.IsSameAs(_realmObject)) { return(WeaveResult.Warning($"{type.Name}.{columnName} is not an automatic property but its type is a RealmObject which normally indicates a relationship.")); } return(WeaveResult.Skipped()); } if (_typeTable.ContainsKey(prop.PropertyType.FullName)) { // If the property is automatic but doesn't have a setter, we should still ignore it. if (prop.SetMethod == null) { return(WeaveResult.Skipped()); } var typeId = prop.PropertyType.FullName + (isPrimaryKey ? " unique" : string.Empty); if (!methodTable.ContainsKey(typeId)) { var getter = _realmObject.LookupMethodReference("Get" + _typeTable[prop.PropertyType.FullName] + "Value", ModuleDefinition); var setter = _realmObject.LookupMethodReference("Set" + _typeTable[prop.PropertyType.FullName] + "Value" + (isPrimaryKey ? "Unique" : string.Empty), ModuleDefinition); methodTable[typeId] = Tuple.Create(getter, setter); } ReplaceGetter(prop, columnName, methodTable[typeId].Item1); ReplaceSetter(prop, backingField, columnName, methodTable[typeId].Item2); } // treat IList and RealmList similarly but IList gets a default so is useable as standalone // IList or RealmList allows people to declare lists only of _realmObject due to the class definition else if (prop.IsIList()) { var elementType = ((GenericInstanceType)prop.PropertyType).GenericArguments.Single(); if (!elementType.Resolve().BaseType.IsSameAs(_realmObject)) { return(WeaveResult.Warning($"SKIPPING {type.Name}.{columnName} because it is an IList but its generic type is not a RealmObject subclass, so will not persist.")); } if (prop.SetMethod != null) { return(WeaveResult.Error($"{type.Name}.{columnName} has a setter but its type is a IList which only supports getters.")); } var concreteListType = new GenericInstanceType(_system_IList) { GenericArguments = { elementType } }; var listConstructor = concreteListType.Resolve().GetConstructors().Single(c => c.IsPublic && c.Parameters.Count == 0); var concreteListConstructor = listConstructor.MakeHostInstanceGeneric(elementType); // weaves list getter which also sets backing to List<T>, forcing it to accept us setting it post-init var backingDef = backingField as FieldDefinition; if (backingDef != null) { backingDef.Attributes &= ~FieldAttributes.InitOnly; // without a set; auto property has this flag we must clear } ReplaceListGetter(prop, backingField, columnName, new GenericInstanceMethod(_genericGetListValueReference) { GenericArguments = { elementType } }, ModuleDefinition.ImportReference(concreteListConstructor)); } else if (prop.PropertyType.Resolve().BaseType.IsSameAs(_realmObject)) { if (!prop.IsAutomatic()) { return(WeaveResult.Warning($"{type.Name}.{columnName} is not an automatic property but its type is a RealmObject which normally indicates a relationship.")); } // with casting in the _realmObject methods, should just work ReplaceGetter(prop, columnName, new GenericInstanceMethod(_genericGetObjectValueReference) { GenericArguments = { prop.PropertyType } }); ReplaceSetter(prop, backingField, columnName, new GenericInstanceMethod(_genericSetObjectValueReference) { GenericArguments = { prop.PropertyType } }); } else if (prop.PropertyType.FullName == "System.DateTime") { return(WeaveResult.Error($"Class '{type.Name}' field '{prop.Name}' is a DateTime which is not supported - use DateTimeOffset instead.")); } else if (prop.PropertyType.FullName == "System.Nullable`1<System.DateTime>") { return(WeaveResult.Error($"Class '{type.Name}' field '{prop.Name}' is a DateTime? which is not supported - use DateTimeOffset? instead.")); } else { return(WeaveResult.Error($"Class '{type.Name}' field '{columnName}' is a '{prop.PropertyType}' which is not yet supported.")); } var preserveAttribute = new CustomAttribute(_preserveAttributeConstructor); prop.CustomAttributes.Add(preserveAttribute); var wovenPropertyAttribute = new CustomAttribute(_wovenPropertyAttributeConstructor); prop.CustomAttributes.Add(wovenPropertyAttribute); Debug.WriteLine(string.Empty); var primaryKeyMsg = isPrimaryKey ? "[PrimaryKey]" : string.Empty; var indexedMsg = isIndexed ? "[Indexed]" : string.Empty; LogDebug($"Woven {type.Name}.{prop.Name} as a {prop.PropertyType.FullName} {primaryKeyMsg} {indexedMsg}."); return(WeaveResult.Success(prop, backingField, isPrimaryKey)); }