public void AddExactConverter <TSource, TDestination>(Func <TSource, TDestination> func)
{
FuncAsyncConverter converter = (src, attr, context) => Task.FromResult <object>(func((TSource)src));
FuncConverterBuilder builder = (srcType, destType) => converter;
this.AddConverter <TSource, TDestination, System.Attribute>(builder);
}
public static PatternMatcher New <TSource, TDest, TAttribute>(Func <TSource, TAttribute, TDest> func)
where TAttribute : System.Attribute
{
FuncAsyncConverter converter = (src, attr, ctx) => Task.FromResult <object>(func((TSource)src, (TAttribute)attr));
return(new CreateFromDelegate(converter));
}
public void OpenTypeTest()
{
int count = 0;
var cm = new ConverterManager();
// Register a converter builder.
// Builder runs once; converter runs each time.
// Uses open type to match.
cm.AddConverter <TypeWrapperIsString, int, Attribute>(
(typeSrc, typeDest) =>
{
count++;
Assert.Equal(typeof(String), typeSrc);
Assert.Equal(typeof(int), typeDest);
FuncAsyncConverter converter2 = (input, attr, ctx) =>
{
string s = (string)input;
return(Task.FromResult <object>(int.Parse(s)));
};
return(converter2);
});
var converter = cm.GetSyncConverter <string, int, Attribute>();
Assert.NotNull(converter);
Assert.Equal(12, converter("12", new TestAttribute(null), null));
Assert.Equal(34, converter("34", new TestAttribute(null), null));
Assert.Equal(1, count); // converterBuilder is only called once.
// 'char' as src parameter doesn't match the type predicate.
Assert.Null(cm.GetSyncConverter <char, int, Attribute>());
}
/// <summary>
/// Register a new converter function that is influenced by the attribute.
/// If TSource is object, then this converter is applied to any attempt to convert to TDestination.
/// </summary>
/// <typeparam name="TSource">Source type.</typeparam>
/// <typeparam name="TDestination">Destination type.</typeparam>
/// <typeparam name="TAttribute">Attribute on the binding. </typeparam>
/// <param name="converterManager"></param>
/// <param name="converter">A function to convert from the source to the destination type.</param>
public static void AddConverter <TSource, TDestination, TAttribute>(this ConverterManager converterManager, FuncAsyncConverter <TSource, TDestination> converter)
where TAttribute : Attribute
{
FuncAsyncConverter func = (src, attr, context) => Task.FromResult <object>(converter((TSource)src, attr, context));
FuncConverterBuilder builder = (srcType, destType) => func;
converterManager.AddConverter <TSource, TDestination, TAttribute>(builder);
}
// Add a 'global' converter for all Attributes.
// Passing in the cancellationToken also helps C# overload resolution determine sync. vs. async
public void AddExactConverter <TSource, TDestination>(Func <TSource, CancellationToken, Task <TDestination> > func)
{
FuncAsyncConverter converter = async(src, attr, context) => await func((TSource)src, CancellationToken.None);
FuncConverterBuilder builder = (srcType, destType) => converter;
this.AddConverter <TSource, TDestination, System.Attribute>(builder);
}
/// <summary>
/// Add a converter that that uses open types.
/// Src type must handle object since it could be unknown.
/// But it's converting to a well-known destination type.
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <typeparam name="TDestination"></typeparam>
/// <param name="func"></param>
/// <returns></returns>
public TThis AddOpenConverter <TSource, TDestination>(FuncAsyncConverter func)
{
var pm = PatternMatcher.New(func);
this.AddConverterBuilder <TSource, TDestination>(pm);
return((TThis)(object)this);
}
/// <summary>
/// Add converter that uses the control attribute.
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <typeparam name="TDestination"></typeparam>
/// <param name="func"></param>
/// <returns></returns>
public TThis AddConverter <TSource, TDestination>(FuncAsyncConverter <TSource, TDestination> func)
{
VerifyNotOpenTypes <TSource, TDestination>();
var pm = PatternMatcher.New(func);
this.AddConverterBuilder <TSource, TDestination>(pm);
return((TThis)(object)this);
}
public static FuncConverterBuilder GetBuilder <TSource, TDestination>(FuncAsyncConverter <TSource, TDestination> func)
{
FuncConverterBuilder builder = (srcType, destType) =>
{
// Cast from TDestination --> Object
return(async(input, attr, ctx) => (object) await func((TSource)input, attr, ctx));
};
return(builder);
}
public BlobCollectionConverter(BlobsExtensionConfigProvider parent)
{
IConverterManager cm = parent._converterManager;
_converter = cm.GetConverter <BlobBaseClient, T, BlobAttribute>();
if (_converter == null)
{
throw new InvalidOperationException($"Can't convert blob to {typeof(T).FullName}.");
}
}
public ExactBinding(
AttributeCloner <TAttribute> cloner,
ParameterDescriptor param,
FuncAsyncConverter buildFromAttribute,
FuncAsyncConverter converter,
Type parameterType) : base(cloner, param)
{
this._buildFromAttribute = buildFromAttribute;
this._converter = converter;
this._parameterType = parameterType;
}
public BindToStreamBindingProvider(
PatternMatcher patternMatcher,
FileAccess access,
INameResolver nameResolver,
IConverterManager converterManager)
{
_builder = patternMatcher.TryGetConverterFunc <TAttribute, Stream>();
_nameResolver = nameResolver;
_converterManager = converterManager;
_access = access;
}
public SimpleTriggerArgumentBinding(
ITriggerBindingStrategy <TMessage, TTriggerValue> hooks,
IConverterManager converterManager,
bool isSingleDispatch = true)
{
this._hooks = hooks;
this.Contract = Hooks.GetBindingContract(isSingleDispatch);
this.ElementType = typeof(TMessage);
_converterManager = converterManager;
_stringConverter = _converterManager.GetConverter <TMessage, string, Attribute>();
}
public ExactBinding(
AttributeCloner <TAttribute> cloner,
ParameterDescriptor param,
Mode mode,
FuncAsyncConverter buildFromAttribute,
FuncAsyncConverter <TMessage, TType> converter) : base(cloner, param)
{
this._buildFromAttribute = buildFromAttribute;
this._mode = mode;
this._converter = converter;
}
public CustomTriggerArgumentBinding(
ITriggerBindingStrategy <TMessage, TTriggerValue> bindingStrategy,
IConverterManager converterManager,
FuncAsyncConverter <TMessage, TUserType> converter) :
base(bindingStrategy, converterManager)
{
if (converter == null)
{
throw new ArgumentNullException("converter");
}
this._converter = converter;
this.ElementType = typeof(TUserType);
}
public override FuncAsyncConverter Execute(object instance)
{
IConverter <TSrc, TDest> converter = (IConverter <TSrc, TDest>)instance;
FuncAsyncConverter func = (input, attr, ctx) =>
{
TSrc src = (TSrc)input;
var result = converter.Convert(src);
return(Task.FromResult <object>(result));
};
return(func);
}
public PocoEntityValueBinder(
TableEntityContext entityContext,
ValueBindingContext context,
TableEntity originalEntity,
FuncAsyncConverter entityToPocoConverter,
FuncAsyncConverter pocoToEntityConverter)
{
_entityContext = entityContext;
_valueBindingContext = context;
_originalEntity = originalEntity;
_entityToPocoConverter = entityToPocoConverter;
_pocoToEntityConverter = pocoToEntityConverter;
}
public override FuncAsyncConverter Execute(object instance)
{
IAsyncConverter <TSrc, TDest> converter = (IAsyncConverter <TSrc, TDest>)instance;
FuncAsyncConverter func = async(input, attr, ctx) =>
{
TSrc src = (TSrc)input;
var cts = ctx == null ? CancellationToken.None : ctx.CancellationToken;
TDest result = await converter.ConvertAsync(src, cts);
return(result);
};
return(func);
}
public TypedAsyncCollectorAdapter(
IAsyncCollector <TDest> inner,
FuncAsyncConverter <TSrc, TDest> convert,
TAttribute attrResolved,
ValueBindingContext context)
{
if (convert == null)
{
throw new ArgumentNullException("convert");
}
_inner = inner;
_convert = convert;
_attrResolved = attrResolved;
_context = context;
}
public void UseValueBindingContext()
{
var cm = new ConverterManager(); // empty
Guid instance = Guid.NewGuid();
var testContext = new ValueBindingContext(new FunctionBindingContext(instance, CancellationToken.None, null), CancellationToken.None);
FuncAsyncConverter converter =
(object obj, Attribute attr, ValueBindingContext ctx) => {
Assert.Same(ctx, testContext);
var result = JObject.FromObject(obj);
result["$"] = ctx.FunctionInstanceId;
return(Task.FromResult <object>(result));
};
cm.AddConverter <object, JObject, Attribute>(converter);
cm.AddConverter <JObject, Wrapper>(str => new Wrapper {
Value = str.ToString()
});
// Expected:
// Other --> JObject,
// JObject --> string , (builtin)
// string --> Wrapper
var func = cm.GetSyncConverter <Other, Wrapper, Attribute>();
var value = new Other {
Value2 = "abc"
};
Wrapper x1 = func(value, null, testContext);
// strip whitespace
string val = Regex.Replace(x1.Value, @"\s", "");
string expected = String.Format("{{\"Value2\":\"abc\",\"$\":\"{0}\"}}", instance);
Assert.Equal(expected, val);
}
public static PatternMatcher New <TSource, TDest>(Func <TSource, CancellationToken, Task <TDest> > func)
{
FuncAsyncConverter converter = async(src, attr, ctx) => await func((TSource)src, ctx.CancellationToken);
return(new CreateFromDelegate(converter));
}
public static PatternMatcher New <TSource, TDest>(Func <TSource, TDest> func)
{
FuncAsyncConverter converter = (src, attr, ctx) => Task.FromResult <object>(func((TSource)src));
return(new CreateFromDelegate(converter));
}
public static ExactBinding <TMessage> TryBuild(
AsyncCollectorBindingProvider <TAttribute, TType> parent,
Mode mode,
BindingProviderContext context)
{
var patternMatcher = parent._patternMatcher;
var parameter = context.Parameter;
var attributeSource = TypeUtility.GetResolvedAttribute <TAttribute>(parameter);
FuncAsyncConverter buildFromAttribute;
FuncAsyncConverter <TMessage, TType> converter = null;
// Prefer the shortest route to creating the user type.
// If TType matches the user type directly, then we should be able to directly invoke the builder in a single step.
// TAttribute --> TUserType
var checker = OpenType.FromType <TType>();
if (checker.IsMatch(typeof(TMessage)))
{
buildFromAttribute = patternMatcher.TryGetConverterFunc(
typeof(TAttribute), typeof(IAsyncCollector <TMessage>));
}
else
{
var converterManager = parent._converterManager;
// Try with a converter
// Find a builder for : TAttribute --> TType
// and then couple with a converter: TType --> TParameterType
converter = converterManager.GetConverter <TMessage, TType, TAttribute>();
if (converter == null)
{
// Preserves legacy behavior. This means we can only have 1 async collector.
// However, the collector's builder object can switch.
throw NewMissingConversionError(typeof(TMessage));
}
buildFromAttribute = patternMatcher.TryGetConverterFunc(
typeof(TAttribute), typeof(IAsyncCollector <TType>));
}
if (buildFromAttribute == null)
{
context.BindingErrors.Add(String.Format(Constants.BindingAssemblyConflictMessage, typeof(TType).AssemblyQualifiedName, typeof(TMessage).AssemblyQualifiedName));
return(null);
}
ParameterDescriptor param;
if (parent.BuildParameterDescriptor != null)
{
param = parent.BuildParameterDescriptor(attributeSource, parameter, parent._nameResolver);
}
else
{
param = new ParameterDescriptor
{
Name = parameter.Name,
DisplayHints = new ParameterDisplayHints
{
Description = "output"
}
};
}
var cloner = new AttributeCloner <TAttribute>(attributeSource, context.BindingDataContract, parent._nameResolver);
return(new ExactBinding <TMessage>(cloner, param, mode, buildFromAttribute, converter));
}
public static PatternMatcher New <TSource, TDest>(FuncAsyncConverter <TSource, TDest> func)
{
FuncAsyncConverter converter = async(input, attr, ctx) => (object) await func((TSource)input, attr, ctx);
return(new CreateFromDelegate(converter));
}
internal static FuncAsyncConverter <TSource, TDestination> AsTyped <TSource, TDestination>(this FuncAsyncConverter func)
{
if (func == null)
{
return(null);
}
return(async(src, attr, ctx) =>
{
var result = await func((TSource)src, attr, ctx);
return (TDestination)result;
});
}
public OutArgBaseValueProvider(object converter)
{
_converter = (FuncAsyncConverter <ApplyConversion <TUserType, Stream>, object>)converter;
}
public ValueProvider(object converter)
{
_converter = (FuncAsyncConverter <Stream, TUserType>)converter;
}
public static ExactBinding TryBuild(
BindToInputBindingProvider <TAttribute, TType> parent,
BindingProviderContext context)
{
var cm = parent._converterManager;
var patternMatcher = parent._patternMatcher;
var parameter = context.Parameter;
var userType = parameter.ParameterType;
var attributeSource = TypeUtility.GetResolvedAttribute <TAttribute>(parameter);
var cloner = new AttributeCloner <TAttribute>(attributeSource, context.BindingDataContract, parent._configuration, parent._nameResolver);
FuncAsyncConverter buildFromAttribute;
FuncAsyncConverter converter = null;
// Prefer the shortest route to creating the user type.
// If TType matches the user type directly, then we should be able to directly invoke the builder in a single step.
// TAttribute --> TUserType
var checker = OpenType.FromType <TType>();
if (checker.IsMatch(userType))
{
buildFromAttribute = patternMatcher.TryGetConverterFunc(typeof(TAttribute), userType);
}
else
{
// Try with a converter
// Find a builder for : TAttribute --> TType
// and then couple with a converter: TType --> TParameterType
converter = cm.GetConverter <TAttribute>(typeof(TType), userType);
if (converter == null)
{
var targetType = typeof(TType);
context.BindingErrors.Add(String.Format(Resource.BindingAssemblyConflictMessage, targetType.AssemblyQualifiedName, userType.AssemblyQualifiedName));
return(null);
}
buildFromAttribute = patternMatcher.TryGetConverterFunc(typeof(TAttribute), typeof(TType));
}
if (buildFromAttribute == null)
{
return(null);
}
ParameterDescriptor param;
if (parent.BuildParameterDescriptor != null)
{
param = parent.BuildParameterDescriptor(attributeSource, parameter, parent._nameResolver);
}
else
{
param = new ParameterDescriptor
{
Name = parameter.Name,
DisplayHints = new ParameterDisplayHints
{
Description = "input"
}
};
}
return(new ExactBinding(cloner, param, buildFromAttribute, converter, userType));
}
public static PatternMatcher New(FuncAsyncConverter func)
{
FuncAsyncConverter converter = func;
return(new CreateFromDelegate(converter));
}
/// <summary>
/// Register a new converter function that is influenced by the attribute.
/// If TSource is object, then this converter is applied to any attempt to convert to TDestination.
/// </summary>
/// <typeparam name="TSource">Source type.</typeparam>
/// <typeparam name="TDestination">Destination type.</typeparam>
/// <typeparam name="TAttribute">Attribute on the binding. </typeparam>
/// <param name="converterManager"></param>
/// <param name="converter">A function to convert from the source to the destination type.</param>
public static void AddConverter <TSource, TDestination, TAttribute>(this ConverterManager converterManager, FuncAsyncConverter converter)
where TAttribute : Attribute
{
FuncConverterBuilder builder = (srcType, destType) => converter;
converterManager.AddConverter <TSource, TDestination, TAttribute>(builder);
}
public PocoEntityArgumentBinding(FuncAsyncConverter entityToPocoConverter, FuncAsyncConverter pocoToEntityConverter)
{
_pocoToEntityConverter = pocoToEntityConverter;
_entityToPocoConverter = entityToPocoConverter;
}
