/// <inheritdoc/> public void Copy( T source, T target, ICopyCallContext copyCallContext) { source.NotNull(nameof(source)); target.NotNull(nameof(target)); copyCallContext.NotNull(nameof(copyCallContext)); var sourceChild = this.sourceFunc.Invoke(source); // if the source is null, set the target also to null and exit copy process step. if (sourceChild == null) { target.SetPropertyValue(this.targetExpression, null); return; } var sourceConcrete = sourceChild as TConcreteChild; sourceConcrete.NotNull(nameof(sourceConcrete)); var copy = this.createCopyHelper.CreateTarget( sourceConcrete, target, copyCallContext); target.SetPropertyValue(this.targetExpression, copy); }
/// <inheritdoc/> public void Copy(T source, T target, ICopyCallContext copyCallContext) { foreach (var registeredStrategy in this.registeredStrategies) { registeredStrategy.Copy(source, target, copyCallContext); } }
/// <inheritdoc/> public void Copy(T source, T target, ICopyCallContext copyCallContext) { copyCallContext.NotNull(nameof(copyCallContext)); this.additionalProcessings.NotNull(nameof(this.additionalProcessings)); copyCallContext.AdditionalProcessings.AddRangeToMe(this.additionalProcessings); }
/// <inheritdoc/> public TChild CreateTarget( TConcreteChild source, TParent reverseRelation, ICopyCallContext copyCallContext) { source.NotNull(nameof(source)); reverseRelation.NotNull(nameof(reverseRelation)); copyCallContext.NotNull(nameof(copyCallContext)); if (copyCallContext.AdditionalProcessings.OfType <IGenericContinueCopyInterception <TChild> >().Any(continueCopyInterception => !continueCopyInterception.ShallCopy(source))) { return(null); } var target = this.instanceCreator.Create(); // Back reference should be set before copy method because copy could potentially use this back reference. target.SetPropertyValue(this.reverseRelationExpr, reverseRelation); this.copy.Copy(source, target, copyCallContext); // Make sure that copy did not overwrite the target's reverse relation therefore back reference is set here // for a second time. target.SetPropertyValue(this.reverseRelationExpr, reverseRelation); return(target); }
public void Copy(IChildTestClass source, IChildTestClass target, ICopyCallContext copyCallContext) { source.Should().NotBeNull(); target.Should().NotBeNull(); copyCallContext.Should().NotBeNull(); target.TestValue = source.TestValue * 2; }
/// <inheritdoc/> public void Copy(T source, T target, ICopyCallContext copyCallContext) { var value = this.func.Invoke(source); var targetProperty = target.GetType().GetProperty(this.propertyName, BindingFlags.Public | BindingFlags.Instance); if (targetProperty != null) { targetProperty.SetValue(target, value, null); } }
/// <inheritdoc/> public virtual void Copy( TBase source, TBase target, ICopyCallContext copyCallContext) { var sourceCastConcrete = source.IsOfType <TDerived>(nameof(source)); var targetCastConcrete = target.IsOfType <TDerived>(nameof(target)); copyCallContext.NotNull(nameof(copyCallContext)); this.copier.Copy(sourceCastConcrete, targetCastConcrete, copyCallContext); }
/// <inheritdoc/> public void Copy( T source, T target, ICopyCallContext copyCallContext) { copyCallContext.NotNull(nameof(copyCallContext)); var crossReferenceHandler = new CopyCrossReferencedCounterPartDeterminationHelper <TCrossReferencedModel, TReferencingModel>( this.referencingProperyExpression); crossReferenceHandler.FillAdditionalProcessings(copyCallContext.AdditionalProcessings); }
/// <inheritdoc/> public void Copy( T source, T target, ICopyCallContext copyCallContext) { source.NotNull(nameof(source)); target.NotNull(nameof(target)); copyCallContext.NotNull(nameof(copyCallContext)); this.operations.Copy(source, target, copyCallContext); this.copyHelper.DoCopyPostProcessing(source, target, copyCallContext.AdditionalProcessings); }
/// <summary> /// <see cref="ICopyOperation{T}"/>. /// </summary> public void Copy( T source, T target, ICopyCallContext copyCallContext) { var newKidsList = new List <TChild>(); foreach (var child in this.sourceFunc.Invoke(source)) { var strategy = this.strategyProvider.GetStrategy(child); var childCopy = strategy.Create(); strategy.Copy(child, childCopy, copyCallContext); childCopy.SetPropertyValue(this.reverseRelationExpression, target); newKidsList.Add(childCopy); } }
/// <summary> /// <see cref="ICopyOperationCreateToManyWithGenericStrategy{T,TStrategy,TChildType}"/>. /// </summary> public void Copy( T source, T target, ICopyCallContext copyCallContext) { var newKidsList = new List <TChildType>(); foreach (var child in this.sourceFunc.Invoke(source)) { var strategy = this.strategyProvider.GetStrategy(child); var childCopy = this.createTargetChildFunc.Invoke(strategy); strategy.Copy(child, childCopy, copyCallContext); newKidsList.Add(childCopy); } target.AddRangeFilterNullValues(this.targetExpression, newKidsList); }
/// <summary> /// <see cref="ICopyOperation{T}"/>. /// </summary> public void Copy( T source, T target, ICopyCallContext copyCallContext) { var sourceChild = this.sourceFunc.Invoke(source); // if the source is null, set the target also to null and exit copy process step. if (sourceChild == null) { target.SetPropertyValue(this.targetExpression, null); return; } var strategy = this.strategyProvider.GetStrategy(sourceChild); var copy = strategy.Create(); strategy.Copy(sourceChild, copy, copyCallContext); copy.SetPropertyValue(this.reverseRelationExpression, target); target.SetPropertyValue(this.targetExpression, copy); }
/// <inheritdoc/> public void Copy(TParent source, TParent target, ICopyCallContext copyCallContext) { source.NotNull(nameof(source)); target.NotNull(nameof(target)); copyCallContext.NotNull(nameof(copyCallContext)); var sourceValues = this.sourceFunc.Invoke(source)?.ToList(); sourceValues.NotNull(nameof(sourceValues)); // ReSharper disable once AssignNullToNotNullAttribute -> .NotNull is called before! var copies = sourceValues.Select(sourceValue => this.createCopyHelper.CreateTarget( sourceValue as TConcreteChild, target, copyCallContext)).ToList(); this.maybeTargetExpression.Do(targetExpression => { target.AddRangeFilterNullValues( targetExpression, copies); }); }
/// <summary> /// <see cref="ICopyOperation{T}.Copy"/>. /// </summary> public void Copy(T source, T target, ICopyCallContext copyCallContext) { var value = this.attrValueFunc.Invoke(this.attributeValueFactory); target.SetPropertyValue(this.targetExpression, value); }
/// <inheritdoc/> public void Copy(T source, T target, ICopyCallContext copyCallContext) { target.SetPropertyValue(this.targetExpression, this.valueFunc.Invoke()); }
/// <inheritdoc/> public void Copy(T source, T target, ICopyCallContext copyCallContext) { this.copier.Copy(source, target, copyCallContext); }