public static PipeOutputPackage Infer(PipeOutputPackage basedOffPackage, Type inputType, Type outputType,
PipeCallback processCallbackFunc)
{
int weight = basedOffPackage.NextChainingWeight();
return(new PipeOutputPackage(weight, inputType, outputType, processCallbackFunc));
}
public async Task GivenEchoCallback_WhenItIsCalledWithInput_ItShouldReturnTheInput()
{
PipeCallback processCallbackFunc = (input, broker) => Task.FromResult(input);
PipeOutputPackage pipePackageOption = PipeOutputPackage.Direct(typeof(string), typeof(string),
processCallbackFunc);
object output = await pipePackageOption.ProcessInput("abc", null);
Assert.AreEqual("abc", output);
}
public void GivenCallbackWhichReturnsNull_WhenLegallyCalled_ItShouldThrowUnexpectedPipePackageOperationException
()
{
PipeCallback processCallbackFunc = (input, broker) => null;
PipeOutputPackage pipePackageOption = PipeOutputPackage.Direct(typeof(string), typeof(string),
processCallbackFunc);
Assert.Throws <UnexpectedPipePackageOperationException>(
async() => await pipePackageOption.ProcessInput("abc", null));
}
GivenProcessorWhichReturnsString_WhenProcesCallbackReturnsInteger_ItShouldThrowUnexpectedPipePackageOperationException
()
{
PipeCallback processCallbackFunc = (input, broker) => Task.FromResult((object)2);
PipeOutputPackage pipePackageOption = PipeOutputPackage.Direct(typeof(string), typeof(string),
processCallbackFunc);
Assert.Throws <UnexpectedPipePackageOperationException>(
async() => await pipePackageOption.ProcessInput("abc", null));
}
public void Ctor_WhenNullToProcessCallbackFuncParameter_ItShouldThrowArgumentNullExcpetion()
{
var argumentNullException = Assert.Throws <ArgumentNullException>(() =>
{
PipeOutputPackage pipePackageOption = PipeOutputPackage.Direct(typeof(string), typeof(string), null);
Assert.Fail();
});
Assert.AreEqual("processCallbackFunc", argumentNullException.ParamName);
}
public void GivenPackageWhichProcessesIntegers_WhenInputParameterIsStringType_ItShouldThrowNotArgumentException()
{
PipeCallback processCallbackFunc = (input, broker) => Task.FromResult((object)"abc");
PipeOutputPackage pipePackageOption = PipeOutputPackage.Direct(typeof(int), typeof(string),
processCallbackFunc);
var argumentException =
Assert.Throws <ArgumentException>(async() => await pipePackageOption.ProcessInput("abc", null));
Assert.AreEqual("input", argumentException.ParamName);
}
public void GivenPackageInstance_WhenNullPassedIntoInputParameter_ItShouldThrowArgumentNullException()
{
PipeCallback processCallbackFunc = (input, broker) => null;
PipeOutputPackage pipePackageOption = PipeOutputPackage.Direct(typeof(string), typeof(string),
processCallbackFunc);
var argumentNullException =
Assert.Throws <ArgumentNullException>(async() => await pipePackageOption.ProcessInput(null, null));
Assert.AreEqual("input", argumentNullException.ParamName);
}
private static PipeOutputPackage CreatePipeOutputPackage <TSource, TDestination>(
Func <TSource, ISemanticBroker, TDestination> processCallback)
{
PipeCallback wrappedProcessCallback = (input, broker) =>
{
var castedInput = (TSource)input;
object result = processCallback(castedInput, broker);
return(result.IntoTaskResult());
};
return(PipeOutputPackage.Direct(typeof(TSource), typeof(TDestination), wrappedProcessCallback));
}
public void Ctor_WhenNullToOutputTypeParameter_ItShouldThrowArgumentNullExcpetion()
{
var argumentNullException = Assert.Throws <ArgumentNullException>(() =>
{
PipeCallback processCallbackFunc = (input, broker) => null;
PipeOutputPackage pipePackageOption = PipeOutputPackage.Direct(typeof(string), null,
processCallbackFunc);
Assert.Fail();
});
Assert.AreEqual("outputType", argumentNullException.ParamName);
}
private static PipeOutputPackage CreateAsyncPipeOutputPackage <TSource, TDestination>(
Func <TSource, ISemanticBroker, Task <TDestination> > processCallback)
{
PipeCallback wrappedProcessCallback = (input, broker) =>
{
var castedInput = (TSource)input;
return
(processCallback(castedInput, broker)
.ContinueWith(task => (object)task.Result));
};
return(PipeOutputPackage.Direct(typeof(TSource), typeof(TDestination), wrappedProcessCallback));
}
public Task <TDestination> Output <TDestination>()
{
PipeOutputPackage solvedPipePackage = _solver.SolveAsPipePackage(typeof(TSource), typeof(TDestination));
Func <object, object> transformInput =
TransformerFactory.ConvertFor(typeof(TSource), solvedPipePackage.InputType);
Func <object, object> transformOutput =
TransformerFactory.ConvertFor(solvedPipePackage.OutputType, typeof(TDestination));
var input = transformInput(_source);
return
(solvedPipePackage.ProcessInput(input, _broker)
.ContinueWith(task => (TDestination)transformOutput(task.Result)));
}
public SemanticBuilder InstallPipe <TSource, TDestination>(
Func <TSource, ISemanticBroker, Task <TDestination> > processCallback)
{
if (processCallback == null)
{
throw new ArgumentNullException("processCallback");
}
PipeOutputPackage package = CreateAsyncPipeOutputPackage(processCallback);
_registryMediator.AppendPackage(package);
return(this);
}
public void UpdateShortestPath(PipeOutputPackage package)
{
bool isShorterPath = RegisterShortestTransistion(package);
if (!isShorterPath)
{
return;
}
RegisterEdge(_outgoingEdges, package.InputType, package.OutputType);
RegisterEdge(_incomingEdges, package.OutputType, package.InputType);
RecursivelySplayOutgoingTransistions(package);
RecursivelyBackFillIncomingTransitions(package);
}
private void RecursivelySplayOutgoingTransistions(PipeOutputPackage package)
{
List <Type> nextOutgoingNodes;
if (!_outgoingEdges.TryGetValue(package.OutputType, out nextOutgoingNodes))
{
return;
}
IEnumerable <PipeOutputPackage> bridgingPackages =
from descendantOutgoingNode in nextOutgoingNodes
where descendantOutgoingNode != package.OutputType
let transitionKey = new Tuple <Type, Type>(package.OutputType, descendantOutgoingNode)
let outgoingPackage = _shortestTransistions[transitionKey]
select PipeOutputPackage.Bridge(package, outgoingPackage);
RecursivelyUpdateShortestPath(bridgingPackages);
}
private void RecursivelyBackFillIncomingTransitions(PipeOutputPackage package)
{
List <Type> nextIncomingNodes;
if (!_incomingEdges.TryGetValue(package.InputType, out nextIncomingNodes))
{
return;
}
IEnumerable <PipeOutputPackage> bridgingPackages =
from ancestorIncomingType in nextIncomingNodes
where ancestorIncomingType != package.InputType
let transitionKey = new Tuple <Type, Type>(ancestorIncomingType, package.InputType)
let incomingPackage = _shortestTransistions[transitionKey]
select PipeOutputPackage.Bridge(incomingPackage, package);
RecursivelyUpdateShortestPath(bridgingPackages);
}
private bool RegisterShortestTransistion(PipeOutputPackage package)
{
var keyToLookup = new Tuple <Type, Type>(package.InputType, package.OutputType);
PipeOutputPackage currentlyKnownPath;
if (_shortestTransistions.TryGetValue(keyToLookup, out currentlyKnownPath))
{
if (package.Weight < currentlyKnownPath.Weight)
{
_shortestTransistions[keyToLookup] = package;
return(true);
}
}
else
{
_shortestTransistions.Add(keyToLookup, package);
return(true);
}
return(false);
}
public static PipeOutputPackage Bridge(PipeOutputPackage startPackage, PipeOutputPackage endPackage)
{
if (startPackage.OutputType != endPackage.InputType)
{
throw new NotSupportedException();
}
Type sourceType = startPackage.InputType;
Type destinationType = endPackage.OutputType;
int weight = startPackage.Weight + endPackage.Weight;
PipeCallback processCallbackFunc =
(input, broker) =>
startPackage.ProcessInput(input, broker)
.ContinueWith(startTask =>
{
object intermediate = startTask.Result;
return(endPackage.ProcessInput(intermediate, broker));
}).Unwrap();
return(new PipeOutputPackage(weight, sourceType, destinationType, processCallbackFunc));
}
public static PipeOutputPackage Bridge(PipeOutputPackage startPackage, PipeOutputPackage endPackage)
{
if (startPackage.OutputType != endPackage.InputType)
{
throw new NotSupportedException();
}
Type sourceType = startPackage.InputType;
Type destinationType = endPackage.OutputType;
int weight = startPackage.Weight + endPackage.Weight;
PipeCallback processCallbackFunc =
(input, broker) =>
startPackage.ProcessInput(input, broker)
.ContinueWith(startTask =>
{
object intermediate = startTask.Result;
return endPackage.ProcessInput(intermediate, broker);
}).Unwrap();
return new PipeOutputPackage(weight, sourceType, destinationType, processCallbackFunc);
}
public static PipeOutputPackage Infer(PipeOutputPackage basedOffPackage, Type inputType, Type outputType,
PipeCallback processCallbackFunc)
{
int weight = basedOffPackage.NextChainingWeight();
return new PipeOutputPackage(weight, inputType, outputType, processCallbackFunc);
}
public IEnumerable <PipeOutputPackage> PipePackageInstalled(PipeOutputPackage package)
{
return(_callbackFunc(package));
}
public IEnumerable<PipeOutputPackage> PipePackageInstalled(PipeOutputPackage package)
{
return _callbackFunc(package);
}