private PipeOutputPackage ExposeConversion(Type elementType, Type baseType, PipeOutputPackage package) { Type inputType = typeof(IEnumerable <>).MakeGenericType(elementType); Type outputType = typeof(IEnumerable <>).MakeGenericType(baseType); return(PipeOutputPackage.Infer(package, inputType, outputType, (input, broker) => input.IntoTaskResult())); }
public IEnumerable <PipeOutputPackage> PipePackageInstalled(PipeOutputPackage package) { if (package.InputType.IsEnumerable() || package.OutputType.IsEnumerable()) { yield break; } MethodInfo castingMethodInfo = GenericCastingMethodInfo.MakeGenericMethod(package.OutputType); Type inputType = typeof(IEnumerable <>).MakeGenericType(package.InputType); Type outputType = typeof(IEnumerable <>).MakeGenericType(package.OutputType); PipeCallback processCallbackFunc = (rawInputStream, broker) => { var inputEnumerable = (IEnumerable)rawInputStream; var pipe = from input in inputEnumerable.Cast <object>() select package.ProcessInput(input, broker); return(Task.Factory.ContinueWhenAll(pipe.ToArray(), tasks => tasks.Select(t => t.Result)) .ContinueWith(resultTask => { object results = resultTask.Result; return castingMethodInfo.Invoke(results, new[] { results }); })); }; yield return(PipeOutputPackage.Infer(package, inputType, outputType, processCallbackFunc)); }
public IEnumerable<PipeOutputPackage> PipePackageInstalled(PipeOutputPackage package) { if (package.InputType.IsEnumerable() || package.OutputType.IsEnumerable()) { yield break; } MethodInfo castingMethodInfo = GenericCastingMethodInfo.MakeGenericMethod(package.OutputType); Type inputType = typeof (IEnumerable<>).MakeGenericType(package.InputType); Type outputType = typeof (IEnumerable<>).MakeGenericType(package.OutputType); PipeCallback processCallbackFunc = (rawInputStream, broker) => { var inputEnumerable = (IEnumerable) rawInputStream; var pipe = from input in inputEnumerable.Cast<object>() select package.ProcessInput(input, broker); return Task.Factory.ContinueWhenAll(pipe.ToArray(), tasks => tasks.Select(t => t.Result)) .ContinueWith(resultTask => { object results = resultTask.Result; return castingMethodInfo.Invoke(results, new[] {results}); }); }; yield return PipeOutputPackage.Infer(package, inputType, outputType, processCallbackFunc); }
private PipeOutputPackage ExposeConversion(Type elementType, Type baseType, PipeOutputPackage package) { Type inputType = typeof (IEnumerable<>).MakeGenericType(elementType); Type outputType = typeof (IEnumerable<>).MakeGenericType(baseType); return PipeOutputPackage.Infer(package, inputType, outputType, (input, broker) => input.IntoTaskResult()); }
private static PipeOutputPackage SimplifyOutput(PipeOutputPackage package) { Type newOutputType = DetermineNewInterestType(package.OutputType); return newOutputType == package.OutputType ? package : PipeOutputPackage.Direct(package.InputType, newOutputType, package.ProcessInput); }
private static PipeOutputPackage SimplifyOutput(PipeOutputPackage package) { Type newOutputType = DetermineNewInterestType(package.OutputType); return(newOutputType == package.OutputType ? package : PipeOutputPackage.Direct(package.InputType, newOutputType, package.ProcessInput)); }
private static void GuardAgainstUnsolveableInputOutputResolution( Type inputType, Type outputType, PipeOutputPackage solvedPackage) { if (solvedPackage != null && solvedPackage.OutputType == outputType) return; string message = string.Format("The input type '{0}' could not be resolved to output a type of {1}", inputType, outputType); throw new CannotResolveSemanticException(message); }
public IEnumerable<PipeOutputPackage> PipePackageInstalled(PipeOutputPackage package) { return from observer in _observers let newPackagesToInstall = observer.PipePackageInstalled(package) where newPackagesToInstall != null from additionalPackage in newPackagesToInstall select additionalPackage; }
public IEnumerable <PipeOutputPackage> PipePackageInstalled(PipeOutputPackage package) { return (from observer in _observers let newPackagesToInstall = observer.PipePackageInstalled(package) where newPackagesToInstall != null from additionalPackage in newPackagesToInstall select additionalPackage); }
private PipeOutputPackage ConvertToDataType(Type inputType, PipeOutputPackage basedOffPackage) { PipeCallback processCallbackFunc = (input, broker) => { Array array = Array.CreateInstance(inputType, 1); array.SetValue(input, 0); return ((object)array).IntoTaskResult(); }; Type outputType = typeof (IEnumerable<>).MakeGenericType(inputType); return PipeOutputPackage.Infer(basedOffPackage, inputType, outputType, processCallbackFunc); }
private static void GuardAgainstUnsolveableInputOutputResolution( Type inputType, Type outputType, PipeOutputPackage solvedPackage) { if (solvedPackage != null && solvedPackage.OutputType == outputType) { return; } string message = string.Format("The input type '{0}' could not be resolved to output a type of {1}", inputType, outputType); throw new CannotResolveSemanticException(message); }
private PipeOutputPackage ConvertToDataType(Type inputType, PipeOutputPackage basedOffPackage) { PipeCallback processCallbackFunc = (input, broker) => { Array array = Array.CreateInstance(inputType, 1); array.SetValue(input, 0); return(((object)array).IntoTaskResult()); }; Type outputType = typeof(IEnumerable <>).MakeGenericType(inputType); return(PipeOutputPackage.Infer(basedOffPackage, inputType, outputType, processCallbackFunc)); }
public IEnumerable<PipeOutputPackage> PipePackageInstalled(PipeOutputPackage package) { if (!package.IsFromUserRegistration()) { yield break; } var keyToSearchFor = new Tuple<Type, Type>(package.InputType, package.OutputType); if (_registeredPackages.ContainsKey(keyToSearchFor)) { RaiseException(keyToSearchFor); } _registeredPackages.Add(keyToSearchFor, package); }
public IEnumerable <PipeOutputPackage> PipePackageInstalled(PipeOutputPackage package) { IEnumerable <PipeOutputPackage> result = Enumerable.Empty <PipeOutputPackage>(); if (package.InputType.IsEnumerable()) { result = result.Concat(ProcessType(package.InputType, package)); } if (package.OutputType.IsEnumerable()) { result = result.Concat(ProcessType(package.OutputType, package)); } return(result); }
public IEnumerable <PipeOutputPackage> PipePackageInstalled(PipeOutputPackage package) { if (!package.IsFromUserRegistration()) { yield break; } var keyToSearchFor = new Tuple <Type, Type>(package.InputType, package.OutputType); if (_registeredPackages.ContainsKey(keyToSearchFor)) { RaiseException(keyToSearchFor); } _registeredPackages.Add(keyToSearchFor, package); }
public IEnumerable<PipeOutputPackage> PipePackageInstalled(PipeOutputPackage package) { IEnumerable<PipeOutputPackage> result = Enumerable.Empty<PipeOutputPackage>(); if (package.InputType.IsEnumerable()) { result = result.Concat(ProcessType(package.InputType, package)); } if (package.OutputType.IsEnumerable()) { result = result.Concat(ProcessType(package.OutputType, package)); } return result; }
public IEnumerable<PipeOutputPackage> PipePackageInstalled(PipeOutputPackage package) { var key = new Tuple<Type, Type>(package.InputType, package.OutputType); PipeOutputPackage rememberedPackage; bool hasEncounteredPackageBefore = _packages.TryGetValue(key, out rememberedPackage); if (!hasEncounteredPackageBefore) { _packages.Add(key, package); } if (!hasEncounteredPackageBefore || package.Weight < rememberedPackage.Weight) { return _wrappedObserver.PipePackageInstalled(package); } return null; }
public IEnumerable <PipeOutputPackage> PipePackageInstalled(PipeOutputPackage package) { var key = new Tuple <Type, Type>(package.InputType, package.OutputType); PipeOutputPackage rememberedPackage; bool hasEncounteredPackageBefore = _packages.TryGetValue(key, out rememberedPackage); if (!hasEncounteredPackageBefore) { _packages.Add(key, package); } if (!hasEncounteredPackageBefore || package.Weight < rememberedPackage.Weight) { return(_wrappedObserver.PipePackageInstalled(package)); } return(null); }
private static PipeOutputPackage SimplifyInput(PipeOutputPackage package) { Type newInputType = DetermineNewInterestType(package.InputType); if (newInputType == package.InputType) { return package; } PipeCallback processCallbackFunc = (input, broker) => { Func<object, object> transformFunc = TransformerFactory.ConvertFor(newInputType, package.InputType); object revisedInput = transformFunc(input); return package.ProcessInput(revisedInput, broker); }; return PipeOutputPackage.Direct(newInputType, package.OutputType, processCallbackFunc); }
private static PipeOutputPackage SimplifyInput(PipeOutputPackage package) { Type newInputType = DetermineNewInterestType(package.InputType); if (newInputType == package.InputType) { return(package); } PipeCallback processCallbackFunc = (input, broker) => { Func <object, object> transformFunc = TransformerFactory.ConvertFor(newInputType, package.InputType); object revisedInput = transformFunc(input); return(package.ProcessInput(revisedInput, broker)); }; return(PipeOutputPackage.Direct(newInputType, package.OutputType, processCallbackFunc)); }
public IEnumerable<PipeOutputPackage> PipePackageInstalled(PipeOutputPackage package) { Type outputType = package.OutputType; if (outputType.IsEnumerable()) { yield break; } if (outputType.BaseType != null && outputType.BaseType != typeof (object)) { yield return CreateReturnPackage(package, outputType.BaseType); } foreach (Type interfaceImplementation in outputType.GetInterfaces()) { yield return CreateReturnPackage(package, interfaceImplementation); } }
public IEnumerable <PipeOutputPackage> PipePackageInstalled(PipeOutputPackage package) { Type outputType = package.OutputType; if (outputType.IsEnumerable()) { yield break; } if (outputType.BaseType != null && outputType.BaseType != typeof(object)) { yield return(CreateReturnPackage(package, outputType.BaseType)); } foreach (Type interfaceImplementation in outputType.GetInterfaces()) { yield return(CreateReturnPackage(package, interfaceImplementation)); } }
private IEnumerable<PipeOutputPackage> ProcessType(Type enumerableType, PipeOutputPackage package) { Type elementType = enumerableType.ExtractEnumerableElementType(); if (elementType == null) { yield break; } if (elementType.BaseType != null && elementType.BaseType != typeof (object)) { yield return ExposeConversion(elementType, elementType.BaseType, package); } IEnumerable<PipeOutputPackage> interfaceInference = from interfaceType in elementType.GetInterfaces() select ExposeConversion(elementType, interfaceType, package); foreach (PipeOutputPackage inferencePackage in interfaceInference) { yield return inferencePackage; } }
public IEnumerable <PipeOutputPackage> PipePackageInstalled(PipeOutputPackage package) { if (!package.InputType.IsEnumerable() && package.OutputType.IsEnumerable()) { Type selfEnumerableType = typeof(IEnumerable <>).MakeGenericType(package.InputType); if (selfEnumerableType.IsAssignableFrom(package.OutputType)) { // this fingerprint shows that we are registering ourselves yield break; } } if (!package.OutputType.IsEnumerable()) { yield return(ConvertToDataType(package.OutputType, package)); } if (!package.InputType.IsEnumerable()) { yield return(ConvertToDataType(package.InputType, package)); } }
private IEnumerable <PipeOutputPackage> ProcessType(Type enumerableType, PipeOutputPackage package) { Type elementType = enumerableType.ExtractEnumerableElementType(); if (elementType == null) { yield break; } if (elementType.BaseType != null && elementType.BaseType != typeof(object)) { yield return(ExposeConversion(elementType, elementType.BaseType, package)); } IEnumerable <PipeOutputPackage> interfaceInference = from interfaceType in elementType.GetInterfaces() select ExposeConversion(elementType, interfaceType, package); foreach (PipeOutputPackage inferencePackage in interfaceInference) { yield return(inferencePackage); } }
public IEnumerable<PipeOutputPackage> PipePackageInstalled(PipeOutputPackage package) { if (!package.InputType.IsEnumerable() && package.OutputType.IsEnumerable()) { Type selfEnumerableType = typeof (IEnumerable<>).MakeGenericType(package.InputType); if (selfEnumerableType.IsAssignableFrom(package.OutputType)) { // this fingerprint shows that we are registering ourselves yield break; } } if (!package.OutputType.IsEnumerable()) { yield return ConvertToDataType(package.OutputType, package); } if (!package.InputType.IsEnumerable()) { yield return ConvertToDataType(package.InputType, package); } }
public IEnumerable <PipeOutputPackage> PipePackageInstalled(PipeOutputPackage package) { _historicalPackages.Add(package); return(null); }
public void AppendPackage(PipeOutputPackage package) { package = SimplifyInput(package); package = SimplifyOutput(package); _nextMediator.AppendPackage(package); }
public void AppendPackage(PipeOutputPackage package) { IEnumerable <PipeOutputPackage> packagesToInsert = new[] { package }; DoPackageInstallations(packagesToInsert); }
public IEnumerable<PipeOutputPackage> PipePackageInstalled(PipeOutputPackage package) { _historicalPackages.Add(package); return null; }
private static PipeOutputPackage CreateReturnPackage(PipeOutputPackage package, Type outputType) { return PipeOutputPackage.Infer(package, package.InputType, outputType, package.ProcessInput); }
public IEnumerable <PipeOutputPackage> PipePackageInstalled(PipeOutputPackage package) { _graphBuilder.UpdateShortestPath(package); return(null); }
public void AppendPackage(PipeOutputPackage package) { _safetyTrip.DoAction(() => _nextMediator.AppendPackage(package)); }
public IEnumerable<PipeOutputPackage> PipePackageInstalled(PipeOutputPackage package) { _graphBuilder.UpdateShortestPath(package); return null; }
private static PipeOutputPackage CreateReturnPackage(PipeOutputPackage package, Type outputType) { return(PipeOutputPackage.Infer(package, package.InputType, outputType, package.ProcessInput)); }
public void AppendPackage(PipeOutputPackage package) { IEnumerable<PipeOutputPackage> packagesToInsert = new[] {package}; DoPackageInstallations(packagesToInsert); }