public void CreateFromFactory_executes_factory_with_resolved_parameters([Frozen] IFulfilsResolutionRequests resolver,
InstanceCreator sut,
IFactoryAdapter factory,
ResolutionPath path,
IServiceRegistration registration,
object resolved,
[MockParam(typeof(string), Name = "Foo")] ParameterInfo paramOne,
object paramOneValue,
[MockParam(typeof(int), Name = "Bar")] ParameterInfo paramTwo,
object paramTwoValue)
{
// Arrange
Mock.Get(factory).SetupGet(x => x.RequiresParameterResolution).Returns(true);
Mock.Get(factory).Setup(x => x.GetParameters()).Returns(new [] { paramOne, paramTwo });
Mock.Get(resolver)
.Setup(x => x.Resolve(It.Is <ResolutionRequest>(r => r.Name == paramOne.Name && r.ServiceType == paramOne.ParameterType)))
.Returns(() => ResolutionResult.Success(path, paramOneValue));
Mock.Get(resolver)
.Setup(x => x.Resolve(It.Is <ResolutionRequest>(r => r.Name == paramTwo.Name && r.ServiceType == paramTwo.ParameterType)))
.Returns(() => ResolutionResult.Success(path, paramTwoValue));
Mock.Get(factory)
.Setup(x => x.Execute(It.Is <object[]>(e => e.Length == 2 && e[0] == paramOneValue && e[1] == paramTwoValue)))
.Returns(resolved);
// Act
var result = sut.CreateFromFactory(factory, path, registration);
// Assert
Mock.Get(factory)
.Verify(x => x.Execute(It.Is <object[]>(e => e.Length == 2 && e[0] == paramOneValue && e[1] == paramTwoValue)), Times.Once);
Assert.That(result, Is.SameAs(resolved));
}
// todo: extensionRootType：将会由 IExtensionPoint<TExtension, TExtensionRoot> 的实现类所在的程序集去引用 ExtensionType 和 ExtensionRootType 所在的程序集，最后的结果会添加到 ReferencedAssemblies，此处不必解析
// apply some rules to extension point.
protected bool ApplyRules(ResolutionResult resolutionResult, ResolutionContext ctx, out TypeResolution extensionType, out TypeResolution extensionRootType)
{
var result = true;
if (!Type.IsClass || Type.IsAbstract)
{
resolutionResult.AddError(string.Format("The specified extension point type [{0}] is not a concrete class!", Type.TypeName));
result = false;
}
//// An extension point can be declared in an addin (extension schema), yet defined in another addin, thus we don't need the following check.
//if (!this.DeclaresInSameAddin())
//{
// resolutionResult.AddError(string.Format(
// "The extension point type [{0}] is expected to be defined and declared in a same addin, while its defining addin is [{1}], and its declaring addin is [{2}], which is not the same as the former!",
// Type.TypeName, Type.Assembly.DeclaringAddin.AddinId.Guid, DeclaringAddin.AddinId.Guid));
// result = false;
//}
extensionRootType = null;
if (!this.InheritFromExtensionPointInterface(resolutionResult, ctx, out extensionType))
{
resolutionResult.AddError(string.Format("The specified extension point type [{0}] does not implement the required interface (IExtensionPoint<TExtension, TRoot>)!", Type.TypeName));
result = false;
}
if (!this.Type.HasPublicParameterLessConstructor())
{
resolutionResult.AddError(string.Format("The specified extension point type [{0}] do not have a public parameter-less constructor!", Type.TypeName));
result = false;
}
return(result);
}
public ResolutionResult Resolve(ResolutionResult source)
{
var level = (Log.SeverityLevel)source.Value;
var @string = level.ToString();
switch (level)
{
case Log.SeverityLevel.Debug:
@string = Resources.Texts_SeverityLevel_Debug;
break;
case Log.SeverityLevel.Info:
@string = Resources.Texts_SeverityLevel_Info;
break;
case Log.SeverityLevel.Warning:
@string = Resources.Texts_SeverityLevel_Warning;
break;
case Log.SeverityLevel.Error:
@string = Resources.Texts_SeverityLevel_Error;
break;
case Log.SeverityLevel.Crud:
@string = Resources.Texts_SeverityLevel_Crud;
break;
}
return(source.New(@string));
}
public ResolutionResult Resolve(ResolutionResult source)
{
var ids = (IList <int>)source.Value;
var tagShowModels = new List <TagShowModel>();
if (!ids.Any())
{
return(source.New(tagShowModels));
}
var tagService = IoC.Get <ITagService>();
foreach (var id in ids)
{
if (tagService.Exists(id))
{
var tag = tagService.Get(id);
var tagShowModel = tag.To <Tag, TagShowModel>();
tagShowModels.Add(tagShowModel);
}
}
return(source.New(tagShowModels));
}
internal override bool TryParse(ResolutionResult resolutionResult, out AddinResolution result)
{
result = new NewOrUpdatedAddinResolution();
bool enabled; AddinHeaderResolution addinHeader;
if (!AddinHeader.TryParse(resolutionResult, result, out enabled, out addinHeader))
{
return(false);
}
List <ExtensionPointResolution> extensionPoints = null; List <ExtensionBuilderResolutionGroup> extensionBuilderGroups = null;
if (ExtensionSchema != null && !ExtensionSchema.TryParse(resolutionResult, result, out extensionPoints, out extensionBuilderGroups))
{
return(false);
}
List <ExtensionResolutionGroup> extensionGroups = null;
if (Extensions != null && !Extensions.TryParse(resolutionResult, result, out extensionGroups))
{
return(false);
}
AddinActivatorResolution addinActivator = null;
if (AddinActivator != null && !AddinActivator.TryParse(resolutionResult, result, out addinActivator))
{
return(false);
}
result.Enabled = enabled;
result.AddinHeader = addinHeader;
result.ManifestFile = ManifestFile;
result.ExtensionBuilderGroups = extensionBuilderGroups;
result.ExtensionPoints = extensionPoints;
result.ExtensionGroups = extensionGroups;
result.AddinActivator = addinActivator;
if (AssemblyFiles != null)
{
result.Assemblies = new List <AssemblyResolution>(AssemblyFiles.Count);
foreach (var assemblyFile in AssemblyFiles)
{
result.Assemblies.Add(AssemblyResolution.CreateAddinAssembly(result, assemblyFile));
}
}
if (DataFiles != null)
{
result.DataFiles = new List <DataFileResolution>(DataFiles.Count);
foreach (var dataFile in DataFiles)
{
result.DataFiles.Add(dataFile);
}
}
return(true);
}
ResolutionResult ResolveNamedInstanceDictionary(ResolutionRequest request)
{
var keyType = dictionaryFactory.GetKeyType(request.ServiceType);
var valueType = dictionaryFactory.GetValueType(request.ServiceType);
var dictionary = dictionaryFactory.Create(keyType, valueType);
var allServiceTypeRegistrations = registrationAccessor.GetAll(valueType);
foreach (var registration in allServiceTypeRegistrations)
{
var serviceResult = ResolveSingleInstance(registration, request);
if (!serviceResult.IsSuccess)
{
// TODO: Throw an exception? Return a failed resolution result? Currently I'm silently skipping the registration.
continue;
}
var dictionaryKey = ConvertToNameType(registration.Name, keyType);
dictionary.Add(dictionaryKey, serviceResult.ResolvedObject);
}
var dictionaryRegistration = CreateNamedInstanceDictionaryRegistration(request.ServiceType, dictionary);
var resolutionPath = request.ResolutionPath.CreateChild(dictionaryRegistration);
return(ResolutionResult.Success(resolutionPath, dictionary));
}
internal override bool Introspect(INameConvention nameConvention, ResolutionResult resolutionResult)
{
var result = true;
if (ExtensionPointName == null)
{
resolutionResult.AddError("An id of extension point must have an parent!");
result = false;
}
if (ParentPath == null)
{
resolutionResult.AddError("An extension builder must have an parent!");
result = false;
}
if (TypeName.IsNullOrWhiteSpace())
{
resolutionResult.AddError("An extension builder must at least provide a type name!");
result = false;
}
if (Name != nameConvention.GetExtensionBuilderName(TypeName))
{
resolutionResult.AddError("The extension builder name and its type name does not comply with the name convention!");
result = false;
}
return(result | DoIntrospect(nameConvention, resolutionResult, "extension builder"));
}
internal override bool TryParse(ResolutionResult resolutionResult, AddinResolution addin, BaseExtensionPointResolution parent,
out ExtensionBuilderResolution result)
{
result = new NewOrUpdatedReferencedExtensionBuilderResolution(addin)
{
Name = Name,
ExtensionPointName = ExtensionPointName,
ParentPath = ParentPath,
Parent = parent
};
if (_children != null)
{
foreach (var child in _children)
{
ExtensionBuilderResolution eb;
if (!child.TryParse(resolutionResult, addin, result, out eb))
{
return(false);
}
eb.ParentPath = Path; // The parent path of an extension builder
eb.ParentIsExtensionPoint = false;
result.AddChild(eb);
}
}
return(true);
}
public ResolutionResult Resolve(ResolutionResult source)
{
var tags = source.Value.ToStringOrNull();
if (tags == null)
{
return(source.New(string.Empty));
}
var titlesList = tags.Split(';');
var idsList = new List <int>();
var tagService = IoC.Get <ITagService>();
foreach (var title in titlesList)
{
if (tagService.Exists(title))
{
var dbTag = tagService.Get(title);
idsList.Add(dbTag.Id);
}
else
{
var newId = tagService.Save(new Tag {
Title = tags
});
idsList.Add(newId);
}
}
return(source.New(idsList));
}
public ResolutionResult Resolve(ResolutionResult source)
{
string key = pInfo.GetValue(source.Value) as string;
string value = dictonary[key];
return(source.New(value));
}
internal bool TryParse(ResolutionResult resolutionResult, AddinResolution addin, Resolvable parent, out ExtensionResolution result)
{
result = null;
ExtensionHeadResolution head;
if (!Head.TryParse(resolutionResult, addin, out head))
{
return(false);
}
result = new NewOrUpdatedExtensionResolution(addin)
{
Data = (Data != null && Data.Items != null ? new ExtensionDataResolution(Data.Items) : null), Head = head, Parent = parent
};
if (_children != null)
{
foreach (var child in _children)
{
ExtensionResolution ex;
if (!child.TryParse(resolutionResult, addin, result, out ex))
{
return(false);
}
result.AddChild(ex);
}
}
return(true);
}
public ResolutionResult Resolve(ResolutionResult source)
{
return(source.New(
((ProfileBase)source.Value)
.GetPropertyValue(source.Context.MemberName)
));
}
public ResolutionResult Resolve(ResolutionResult source)
{
var blogPage = source.Context.SourceValue as Blog;
if (blogPage == null)
{
return(source.Ignore());
}
var context = source.Context.GetHeadRestMappingContext();
if (context == null)
{
return(source.Ignore());
}
var page = context.Request.HeadRestRouteParam("page", 1);
var searcher = ExamineManager.Instance.DefaultSearchProvider;
var criteria = searcher.CreateSearchCriteria()
.Field("nodeTypeAlias", Blogpost.ModelTypeAlias)
.And().Field("searchPath", blogPage.Id.ToInvariantString())
.Not().Field("umbracoNaviHide", "1")
.And().OrderByDescending("publishDate")
.Compile();
var results = searcher.Search(criteria, page * TrackerConstants.BlogPageSize);
var result = new PagedResult <Blogpost>(results.TotalItemCount, page, TrackerConstants.BlogPageSize);
result.Items = results.Skip(result.GetSkipSize())
.Select(x => context.UmbracoContext.ContentCache.GetById(int.Parse(x.Fields["id"])).OfType <Blogpost>());
return(source.New(result));
}
internal bool TryParse(ResolutionResult resolutionResult, AddinResolution addin, out bool enabled, out AddinHeaderResolution result)
{
result = new AddinHeaderResolution {
AddinId = new AddinId()
};
try
{
enabled = Enabled == null ? true : bool.Parse(Enabled);
result.AddinId.Guid = new Guid(Guid);
result.AddinCategory = AddinCategory == null ? Core.AddinCategory.User : (AddinCategory)Enum.Parse(typeof(AddinCategory), AddinCategory);
result.Version = Version == null ? _defaultVersion : new Version(Version);
result.CompatVersion = CompatVersion == null ? _defaultVersion : new Version(CompatVersion);
}
catch (Exception e)
{
enabled = false;
resolutionResult.AddError(string.Format("An exception is thrown while parsing the addin [{0}]! Error: [{1}]", Name, e.Message));
return(false);
//throw new AccessViolationException(e.Message);
}
result.Name = Name;
result.Description = Description;
//result.Url = Url;
result.InnerProperties = Properties;
return(true);
}
public ResolutionResult Resolve(ResolutionResult source)
{
var sourceValue = (string)propertyMapSourceMember.GetValue(source.Context.SourceValue);
var result = new string(sourceValue.Take(length).ToArray());
return(source.New(result));
}
bool ApplyRules(ResolutionResult resolutionResult, ResolutionContext ctx)
{
var result = true;
if (!Type.IsClass || Type.IsAbstract)
{
resolutionResult.AddError(string.Format("The specified addin activator type [{0}] is not a concrete class!", Type.TypeName));
result = false;
}
if (!this.DeclaresInSameAddin())
{
resolutionResult.AddError(string.Format(
"The addin activator type [{0}] is expected to be defined and declared in a same addin, while its defining addin is [{1}], and its declaring addin is [{2}], which is not the same as the former!",
Type.TypeName, Type.Assembly.DeclaringAddin.AddinId.Guid, DeclaringAddin.AddinId.Guid));
result = false;
}
if (!this.InheritFromAddinActivatorInterface(resolutionResult, ctx))
{
resolutionResult.AddError(string.Format("The specified addin activator type [{0}] does not implement the required interface (IAddinActivator)!", Type.TypeName));
result = false;
}
if (!this.Type.HasPublicParameterLessConstructor())
{
resolutionResult.AddError(string.Format("The specified addin activator type [{0}] do not have a public parameter-less constructor!", Type.TypeName));
result = false;
}
return(result);
}
public ResolutionResult Resolve(ResolutionResult source)
{
var importance = (QueuedMailImportance)source.Value;
string value;
switch (importance)
{
case QueuedMailImportance.Low:
value = Members.QueuedMailImportance_Low;
break;
case QueuedMailImportance.Normal:
value = Members.QueuedMailImportance_Normal;
break;
case QueuedMailImportance.High:
value = Members.QueuedMailImportance_High;
break;
case QueuedMailImportance.Critical:
value = Members.QueuedMailImportance_Critical;
break;
default:
throw new NotSupportedEnumException(importance);
}
return(source.New(value));
}
private object ResolveObject(ResolutionResult source)
{
if (!source.Context.Options.Items.ContainsKey("Services"))
{
return(null);
}
var services = (List <object>)source.Context.Options.Items["Services"];
var item = services.FirstOrDefault(s => s is IBaseService <TEntity>);
if (item == null)
{
return(null);
}
var id = (long)source.Value;
if (id <= 0)
{
return(null);
}
var service = (IBaseService <TEntity>)item;
return(service.GetById(id));
}
public ResolutionResult Resolve(ResolutionResult source)
{
var severity = (LogSeverity)source.Value;
string value;
switch (severity)
{
case LogSeverity.Debug:
value = Members.LogSeverity_Debug;
break;
case LogSeverity.Information:
value = Members.LogSeverity_Information;
break;
case LogSeverity.Warning:
value = Members.LogSeverity_Warning;
break;
case LogSeverity.Error:
value = Members.LogSeverity_Error;
break;
case LogSeverity.Fatal:
value = Members.LogSeverity_Fatal;
break;
default:
throw new NotSupportedEnumException(severity);
}
return(source.New(value));
}
// The resolution of an extension point depends on the existence of its implementation type (IExtensionPoint<TExtension, TRoot>),
// extension type (TExtension) and root type (TRoot), and it needs to obey some rules.
protected override ResolutionStatus DoResolve(ResolutionResult resolutionResult, ConvertionManager convertionManager, ResolutionContext ctx)
{
if (Type == null)
{
Type = ctx.GetUniqueAddinType(DeclaringAddin, TypeName);
if (Type == null)
{
resolutionResult.AddError(string.Format("Can not find the specified extension point type [{0}]!", TypeName));
return(ResolutionStatus.Failed);
}
TypeResolution extensionType, extensionRootType;
if (!ApplyRules(resolutionResult, ctx, out extensionType, out extensionRootType))
{
return(ResolutionStatus.Failed);
}
ExtensionType = extensionType;
ExtensionRootType = extensionRootType;
if (Type.Assembly.DeclaringAddin != null &&
!ReferenceEquals(Type.Assembly.DeclaringAddin, DeclaringAddin))
{
AssemblyResolutionSet assemblySet;
if (!ctx.TryGetAssemblySet(Type.Assembly.AssemblyKey, out assemblySet))
{
throw new Exception();
}
DeclaringAddin.AddReferencedAssemblySet(assemblySet);
}
}
return(ResolveType(Type));
}
/// <summary>
/// Create a TenantResolveResult that indicates that the tenant's resolution result of this request.
/// </summary>
/// <param name="resolutionResult"></param>
private TenantResolveResult(ResolutionResult resolutionResult)
{
Value = "";
ResolutionType = ResolutionType.Nothing;
ResolutionResult = resolutionResult;
ErrorMessage = "";
}
public TenantContext(TTenant tenant, ResolutionResult resolutionResult, MappingResult mappingResult, ResolutionType resolvedType)
{
Tenant = tenant;
ResolutionResult = resolutionResult;
MappingResult = mappingResult;
ResolutionType = resolvedType;
}
public ResolutionResult Resolve(ResolutionResult source)
{
var status = (SubscriptionStatus)source.Value;
string value;
switch (status)
{
case SubscriptionStatus.Pending:
value = Members.SubscriptionStatus_Pending;
break;
case SubscriptionStatus.ConfirmationSent:
value = Members.SubscriptionStatus_ConfirmationSent;
break;
case SubscriptionStatus.Confirmed:
value = Members.SubscriptionStatus_Confirmed;
break;
case SubscriptionStatus.Cancelled:
value = Members.SubscriptionStatus_Cancelled;
break;
default:
throw new NotSupportedEnumException(status);
}
return(source.New(value));
}
public void Resolve_resolves_unregistered_service_when_resolution_is_unsuccesful([Frozen, ResolvesToFailure] IResolver proxiedResolver,
[Frozen] IResolvesRegistrations registrationResolver,
[Frozen] IServiceRegistrationProvider unregisteredRegistrationProvider,
UnregisteredServiceResolverProxy sut,
ResolutionPath path,
ResolutionRequest request,
ResolutionResult resolutionResult,
IServiceRegistration registration)
{
// Arrange
Mock.Get(proxiedResolver)
.Setup(x => x.Resolve(request))
.Returns(ResolutionResult.Failure(path));
Mock.Get(unregisteredRegistrationProvider)
.Setup(x => x.Get(request))
.Returns(registration);
Mock.Get(registrationResolver)
.Setup(x => x.Resolve(request, registration))
.Returns(resolutionResult);
// Act
var result = sut.Resolve(request);
// Assert
Assert.That(result, Is.SameAs(resolutionResult));
}
public ResolutionResult Resolve(ResolutionResult source)
{
var idsList = (List <int>)source.Value;
if (idsList == null || !idsList.Any())
{
return(source.New(string.Empty));
}
var titlesList = new List <string>();
var tagService = IoC.Get <ITagService>();
foreach (var id in idsList)
{
if (tagService.Exists(id))
{
var dbTag = tagService.Get(id);
titlesList.Add(dbTag.Title);
}
}
var titles = string.Join(";", titlesList);
return(source.New(titles));
}
protected override ResolutionStatus DoResolve(ResolutionResult resolutionResult, ConvertionManager convertionManager, ResolutionContext ctx)
{
if (Type == null)
{
Type = ctx.GetUniqueAddinType(DeclaringAddin, TypeName);
if (Type == null)
{
resolutionResult.AddError(string.Format("Can not find the specified addin activator type [{0}]!", TypeName));
return(ResolutionStatus.Failed);
}
if (!ApplyRules(resolutionResult, ctx))
{
return(ResolutionStatus.Failed);
}
//if (Type.Assembly.DeclaringAddin != null &&
// !ReferenceEquals(Type.Assembly.DeclaringAddin, DeclaringAddin))
//{
// AssemblyResolutionSet assemblySet;
// if (!ctx.TryGetAssemblySet(Type.Assembly.AssemblyKey, out assemblySet))
// throw new Exception();
// DeclaringAddin.AddReferencedAssemblySet(assemblySet);
//}
}
return(ResolveType(Type));
}
public override ResolutionResult Resolve(ResolutionResult source)
{
var dateTime = (DateTime)base.Resolve(source).Value;
var persianDate = DateTimeHelper.TranslateToPersian(dateTime);
return(source.New(persianDate.Month));
}
public ResolutionResult Resolve(ResolutionResult source)
{
// Add validation for source and destination types
return(source.New(
ResolveCore((int?)source.Value,
DestinationMemberValue(source.Context)),
typeof(int?)));
}
public virtual ResolutionResult Resolve(ResolutionResult source)
{
var result = Resolve((TIn)source.Value, source.Context);
return(result == null
? source.Ignore()
: source.New(result));
}
public ResolutionResult Resolve(ResolutionResult source)
{
var destinationSubEntity = ((Entity)source.Context.DestinationValue).Sub;
Mapper.Map((Dto)source.Value, destinationSubEntity);
return(source.New(destinationSubEntity, typeof(SubEntity)));
}
public ResolutionResult Resolve(ResolutionResult source)
{
var propertyMap = source.Context.PropertyMap;
propertyMap.ShouldNotBeNull();
var codeValueTypeId = propertyMap.SourceMember.DeclaringType.Name + ":" + propertyMap.SourceMember.Name;
return source.New(LookupCodeValue(codeValueTypeId, "" + source.Value));
}
public ResolutionResult Resolve(ResolutionResult source)
{
if (_nullSubstitute == null)
{
return source;
}
return source.Value == null
? source.New(_nullSubstitute)
: source;
}
public ResolutionResult Resolve(ResolutionResult source)
{
try
{
return _inner.Resolve(source);
}
catch (NullReferenceException)
{
return source.New(null, MemberType);
}
}
public ResolutionResult Resolve(ResolutionResult source)
{
if (source.Value == null)
return source;
var valueType = source.Value.GetType();
if (!(_sourceType.IsAssignableFrom(valueType)))
throw new ArgumentException("Expected obj to be of type " + _sourceType + " but was " + valueType);
var result = _propertyInfo.GetValue(source.Value, null);
return source.New(result);
}
public ResolutionResult Resolve(ResolutionResult source)
{
return source.New(-1);
}
public ResolutionResult Resolve(ResolutionResult source)
{
return source.New((int) source.Value + (int)source.Context.Options.Items["Item"]);
}
public ResolutionResult Resolve(ResolutionResult source)
{
return source.Value == null
? source.New(source.Value, MemberType)
: source.New(GetValue(source.Value), MemberType);
}
private void MapPropertyValue(ResolutionContext context, IMappingEngineRunner mapper, object mappedObject, PropertyMap propertyMap)
{
if (propertyMap.CanResolveValue() && propertyMap.ShouldAssignValuePreResolving(context))
{
ResolutionResult result;
Exception resolvingExc = null;
try
{
result = propertyMap.ResolveValue(context);
}
catch (AutoMapperMappingException)
{
throw;
}
catch (Exception ex)
{
var errorContext = CreateErrorContext(context, propertyMap, null);
resolvingExc = new AutoMapperMappingException(errorContext, ex);
result = new ResolutionResult(context);
}
if (result.ShouldIgnore)
return;
object destinationValue = propertyMap.GetDestinationValue(mappedObject);
var sourceType = result.Type;
var destinationType = propertyMap.DestinationProperty.MemberType;
var typeMap = mapper.ConfigurationProvider.FindTypeMapFor(result, destinationType);
Type targetSourceType = typeMap != null ? typeMap.SourceType : sourceType;
var newContext = context.CreateMemberContext(typeMap, result.Value, destinationValue, targetSourceType,
propertyMap);
if (!propertyMap.ShouldAssignValue(newContext))
return;
// If condition succeeded and resolving failed, throw
if (resolvingExc != null)
throw resolvingExc;
try
{
object propertyValueToAssign = mapper.Map(newContext);
AssignValue(propertyMap, mappedObject, propertyValueToAssign);
}
catch (AutoMapperMappingException)
{
throw;
}
catch (Exception ex)
{
throw new AutoMapperMappingException(newContext, ex);
}
}
}
public ResolutionResult Resolve(ResolutionResult source)
{
var resolver = _constructor(source.Context);
return resolver.Resolve(source);
}
public ResolutionResult Resolve(ResolutionResult source)
{
return new ResolutionResult(source.Value);
}
public ResolutionResult Resolve(ResolutionResult source)
{
return source.New(source.Value);
}
