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 void AppendPackage(PipeOutputPackage package)
{
package = SimplifyInput(package);
package = SimplifyOutput(package);
_nextMediator.AppendPackage(package);
}
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;
}
public void AppendPackage(PipeOutputPackage package)
{
_safetyTrip.DoAction(() => _nextMediator.AppendPackage(package));
}
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);
}
