// Provide a strong typed wrapper. public static FuncAsyncConverter <TSource, TDestination> GetConverter <TSource, TDestination, TAttribute>(this IConverterManager converterManager) where TAttribute : Attribute { var func = converterManager.GetConverter <TAttribute>(typeof(TSource), typeof(TDestination)); return(func.AsTyped <TSource, TDestination>()); }
private static Func <TAttribute, IValueProvider> BuildICollectorArgument <TAttribute, TMessage, TMessageSrc>( IConverterManager cm, Func <TAttribute, IAsyncCollector <TMessage> > buildFromAttribute, AttributeCloner <TAttribute> cloner) where TAttribute : Attribute { // Other Func <TMessageSrc, TAttribute, TMessage> convert = cm.GetConverter <TMessageSrc, TMessage, TAttribute>(); if (convert == null) { ThrowMissingConversionError(typeof(TMessageSrc)); } Func <TAttribute, IValueProvider> argumentBuilder = (attrResolved) => { IAsyncCollector <TMessage> raw = buildFromAttribute(attrResolved); IAsyncCollector <TMessageSrc> obj = new TypedAsyncCollectorAdapter <TMessageSrc, TMessage, TAttribute>( raw, convert, attrResolved); ICollector <TMessageSrc> obj2 = new SyncAsyncCollectorAdapter <TMessageSrc>(obj); string invokeString = cloner.GetInvokeString(attrResolved); return(new AsyncCollectorValueProvider <ICollector <TMessageSrc>, TMessage>(obj2, raw, invokeString)); }; return(argumentBuilder); }
private static bool HasConverterWorker <TAttribute, TSrc, TDest>(IConverterManager converterManager) where TAttribute : Attribute { var func = converterManager.GetConverter <TSrc, TDest, TAttribute>(); return(func != null); }
protected string ConvertToString(TMessage eventData) { var convert = _converterManager.GetConverter <TMessage, string, Attribute>(); var result = convert(eventData, null); return(result); }
private static FuncAsyncConverter <DirectInvokeString, TTriggerValue> GetDirectInvoker(IConverterManager cm) { var direct = cm.GetConverter <DirectInvokeString, TTriggerValue, TAttribute>(); if (direct != null) { return(direct); } var str = cm.GetConverter <string, TTriggerValue, TAttribute>(); if (str != null) { return((input, attr, ctx) => str(input.Value, attr, ctx)); } return(null); }
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 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}."); } }
GetDirectTriggerBindingWorker <TMessage, TTriggerValue, TUserType>( ITriggerBindingStrategy <TMessage, TTriggerValue> bindingStrategy, IConverterManager converterManager) { var directConvert = converterManager.GetConverter <TMessage, TUserType, Attribute>(); if (directConvert != null) { var argumentBinding = new CustomTriggerArgumentBinding <TMessage, TTriggerValue, TUserType>( bindingStrategy, converterManager, directConvert); return(argumentBinding); } return(null); }
// Check if a conversion exists. internal static bool HasConverter <TAttribute>(this IConverterManager converterManager, Type typeSource, Type typeDest) where TAttribute : Attribute { try { var converter = converterManager.GetConverter <TAttribute>(typeSource, typeDest); return(converter != null); } catch (InvalidOperationException) { // OpenType match could have thrown. return(false); } }
// Helper to build an argument binder for IAsyncCollector<TMessageSrc> private static Func <TContext, ValueBindingContext, IValueProvider> BuildIAsyncCollectorArgument <TContext, TMessageSrc, TMessage>( IConverterManager cm, Func <TContext, ValueBindingContext, IAsyncCollector <TMessage> > builder, string invokeString) { Func <TMessageSrc, TMessage> convert = cm.GetConverter <TMessageSrc, TMessage>(); Func <TContext, ValueBindingContext, IValueProvider> argumentBuilder = (context, valueBindingContext) => { IAsyncCollector <TMessage> raw = builder(context, valueBindingContext); IAsyncCollector <TMessageSrc> obj = new TypedAsyncCollectorAdapter <TMessageSrc, TMessage>(raw, convert); return(new AsyncCollectorValueProvider <IAsyncCollector <TMessageSrc>, TMessage>(obj, raw, invokeString)); }; return(argumentBuilder); }
public static IArgumentBinding <TableEntityContext> TryCreatePocoBinding(ParameterInfo parameter, IConverterManager converterManager) { if (parameter.ParameterType.IsByRef) { return(null); } if (parameter.ParameterType.ContainsGenericParameters) { return(null); } var pocoToEntityConverter = converterManager.GetConverter <TableAttribute>(parameter.ParameterType, typeof(TableEntity)); var entityToPocoConverter = converterManager.GetConverter <TableAttribute>(typeof(TableEntity), parameter.ParameterType); if (pocoToEntityConverter == null || entityToPocoConverter == null) { return(null); } Type genericType = typeof(PocoEntityArgumentBinding <>).MakeGenericType(parameter.ParameterType); return((IArgumentBinding <TableEntityContext>)Activator.CreateInstance(genericType, entityToPocoConverter, pocoToEntityConverter)); }
private static FuncAsyncConverter <TTriggerValue, DirectInvokeString> GetDirectInvokeString(IConverterManager cm) { var converter = cm.GetConverter <TTriggerValue, DirectInvokeString, TAttribute>(); if (converter != null) { return(converter); } var strConverter = cm.GetConverter <TTriggerValue, string, TAttribute>(); if (strConverter != null) { return(async(input, attr, ctx) => { var str = await strConverter(input, attr, ctx); return new DirectInvokeString(str); }); } // No converter. Provide something to display in UI return((input, attr, ctx) => Task.FromResult(DirectInvokeString.None)); }
// Provide a strong typed wrapper. public static FuncAsyncConverter <TSource, TDestination> GetConverter <TSource, TDestination, TAttribute>(this IConverterManager converterManager) where TAttribute : Attribute { var func = converterManager.GetConverter <TAttribute>(typeof(TSource), typeof(TDestination)); if (func == null) { return(null); } return(async(src, attr, ctx) => { var result = await func((TSource)src, attr, ctx); return (TDestination)result; }); }
// Provide a sync wrapper for convenience in calling. public static FuncConverter <TSource, TAttribute, TDestination> GetSyncConverter <TSource, TDestination, TAttribute>( this IConverterManager converterManager) where TAttribute : Attribute { var func = converterManager.GetConverter <TAttribute>(typeof(TSource), typeof(TDestination)); if (func == null) { return(null); } return((src, attr, ctx) => { var result = Task.Run(() => func((TSource)src, attr, ctx)).GetAwaiter().GetResult(); return (TDestination)result; }); }
static Func <TContext, ValueBindingContext, IValueProvider> BuildOutArgument <TContext, TMessageSrc, TMessage>( IConverterManager cm, Func <TContext, ValueBindingContext, IFlushCollector <TMessage> > builder, string invokeString ) { // Other Func <TMessageSrc, TMessage> convert = cm.GetConverter <TMessageSrc, TMessage>(); Func <TContext, ValueBindingContext, IValueProvider> argumentBuilder = (context, valueBindingContext) => { IFlushCollector <TMessage> raw = builder(context, valueBindingContext); IFlushCollector <TMessageSrc> obj = new TypedAsyncCollectorAdapter <TMessageSrc, TMessage>(raw, convert); return(new OutValueProvider <TMessageSrc>(obj, invokeString)); }; return(argumentBuilder); }
private static Func <TAttribute, IValueProvider> BuildOutArrayArgument <TAttribute, TMessage, TMessageSrc>( IConverterManager cm, Func <TAttribute, IAsyncCollector <TMessage> > buildFromAttribute, AttributeCloner <TAttribute> cloner) where TAttribute : Attribute { // Other Func <TMessageSrc, TAttribute, TMessage> convert = cm.GetConverter <TMessageSrc, TMessage, TAttribute>(); Func <TAttribute, IValueProvider> argumentBuilder = (attrResolved) => { IAsyncCollector <TMessage> raw = buildFromAttribute(attrResolved); IAsyncCollector <TMessageSrc> obj = new TypedAsyncCollectorAdapter <TMessageSrc, TMessage, TAttribute>( raw, convert, attrResolved); string invokeString = cloner.GetInvokeString(attrResolved); return(new OutArrayValueProvider <TMessageSrc>(obj, invokeString)); }; return(argumentBuilder); }
public static ExactBinding <TUserType> TryBuild( TriggerAdapterBindingProvider <TAttribute, TTriggerValue> parent, BindingProviderContext context) { IConverterManager cm = parent._converterManager; var converter = cm.GetConverter <TTriggerValue, TUserType, TAttribute>(); if (converter == null) { return(null); } var parameter = context.Parameter; var attributeSource = TypeUtility.GetResolvedAttribute <TAttribute>(parameter); return(new ExactBinding <TUserType> { _converter = converter, _directInvoker = GetDirectInvoker(cm), _getInvokeString = GetDirectInvokeString(cm), _attribute = attributeSource }); }
public static IBinding TryBuild <TUserType>( BindToStreamBindingProvider <TAttribute> parent, BindingProviderContext context) { // Allowed Param types: // Stream // any T with a Stream --> T conversion // out T, with a Out<Stream,T> --> void conversion var parameter = context.Parameter; var parameterType = parameter.ParameterType; var attributeSource = TypeUtility.GetResolvedAttribute <TAttribute>(parameter); // Stream is either way; all other types are known. FileAccess?declaredAccess = GetFileAccessFromAttribute(attributeSource); Type argHelperType; bool isRead; IConverterManager cm = parent._converterManager; INameResolver nm = parent._nameResolver; IConfiguration config = parent._configuration; object converterParam = null; { if (parameter.IsOut) { var outConverter = cm.GetConverter <ApplyConversion <TUserType, Stream>, object, TAttribute>(); if (outConverter != null) { converterParam = outConverter; isRead = false; argHelperType = typeof(OutArgBaseValueProvider <>).MakeGenericType(typeof(TAttribute), typeof(TUserType)); } else { throw new InvalidOperationException($"No stream converter to handle {typeof(TUserType).FullName}."); } } else { var converter = cm.GetConverter <Stream, TUserType, TAttribute>(); if (converter != null) { converterParam = converter; if (parameterType == typeof(Stream)) { if (!declaredAccess.HasValue) { throw new InvalidOperationException("When binding to Stream, the attribute must specify a FileAccess direction."); } switch (declaredAccess.Value) { case FileAccess.Read: isRead = true; break; case FileAccess.Write: isRead = false; break; default: throw new NotImplementedException("ReadWrite access is not supported. Pick either Read or Write."); } } else { // For backwards compat, we recognize TextWriter as write; // anything else should explicitly set the FileAccess flag. if (typeof(TextWriter).IsAssignableFrom(typeof(TUserType))) { isRead = false; } else { isRead = true; } } argHelperType = typeof(ValueProvider <>).MakeGenericType(typeof(TAttribute), typeof(TUserType)); } else { // This rule can't bind. // Let another try. context.BindingErrors.Add(String.Format(Resource.BindingAssemblyConflictMessage, typeof(Stream).AssemblyQualifiedName, typeof(TUserType).AssemblyQualifiedName)); return(null); } } } VerifyAccessOrThrow(declaredAccess, isRead); if (!parent.IsSupportedByRule(isRead)) { return(null); } var cloner = new AttributeCloner <TAttribute>(attributeSource, context.BindingDataContract, config, nm); ParameterDescriptor param; if (parent.BuildParameterDescriptor != null) { param = parent.BuildParameterDescriptor(attributeSource, parameter, nm); } else { param = new ParameterDescriptor { Name = parameter.Name, DisplayHints = new ParameterDisplayHints { Description = isRead ? "Read Stream" : "Write Stream" } }; } var fileAccess = isRead ? FileAccess.Read : FileAccess.Write; IBinding binding = new StreamBinding(cloner, param, parent, argHelperType, parameterType, fileAccess, converterParam); return(binding); }