protected override void HandleStatement(HandleContext context)
{
AssignmentStatement assignment = (AssignmentStatement)context.Statement;
if (!CoversAssignment(assignment))
{
return;
}
Method sourceConstructor = ExtractConstructor(assignment.Source);
string variableName = IntrospectionUtility.GetVariableName(assignment.Target);
bool fragmentTypeInferenceRequired = FirstParameterIsString(sourceConstructor);
if (fragmentTypeInferenceRequired)
{
Fragment fragmentType = FirstOperandsFragmentType(assignment, context);
context.StringBuilderFragmentTypeDefined[variableName] = true;
context.SymbolTable.MakeSafe(variableName, fragmentType);
}
else
{
//context.StringBuilderFragmentTypeDefined[variableName] = false;
context.SymbolTable.MakeSafe(variableName, Fragment.CreateUndefined());
}
}
public async Task Mediate(TMessage message, IMessageContext messageContext)
{
var handleContext = new HandleContext(message, _cancellationToken);
try
{
await messageContext.RunPreHandlers(handleContext);
foreach (var handler in messageContext.Handlers)
{
await(Task) handler.Value.Handle(handleContext);
}
await messageContext.RunPostHandlers(handleContext);
}
catch (Exception e)
{
if (messageContext.ErrorHandlers.Count + messageContext.IndirectErrorHandlers.Count == 0)
{
throw;
}
handleContext.Exception = e;
await messageContext.RunErrorHandlers(handleContext);
}
}
public void ArrayConstructIsParsed()
{
MockRepository mocks = new MockRepository();
IBlacklistManager blacklistManager = mocks.Stub <IBlacklistManager>();
Dictionary <string, bool> locallyInitializedArrays = new Dictionary <string, bool>();
BlockParserContext blockParserContext = new BlockParserContext(
new ProblemPipeStub(),
Fragment.CreateNamed("returnFragmentType"),
new List <ReturnCondition>(),
blacklistManager,
delegate { });
ArrayConstructStatementHandler handler = new ArrayConstructStatementHandler(blockParserContext);
Method sampleMethod = IntrospectionUtility.MethodFactory <ArrayConstructStatementHandlerSample> ("LocallyInitializedArray");
Block sampleBlock = (Block)sampleMethod.Body.Statements[0];
Statement sample = sampleBlock.Statements[1];
ISymbolTable symbolTable = mocks.Stub <ISymbolTable>();
HandleContext context = new HandleContext(
sample,
symbolTable,
new List <IPreCondition>(),
new List <string>(),
new List <BlockAssignment>(),
new List <int>(),
locallyInitializedArrays,
new Dictionary <string, bool>());
handler.Handle(context);
bool locallyInitializedArrayAdded = locallyInitializedArrays.ContainsKey("local$2") && locallyInitializedArrays["local$2"] == false;
Assert.That(locallyInitializedArrayAdded, Is.True);
}
public void Handle_WrongStatementType_ThrowsException()
{
MockRepository mocks = new MockRepository();
IBlacklistManager blacklistManager = mocks.Stub <IBlacklistManager>();
BlockParserContext blockParserContext = new BlockParserContext(
new ProblemPipeStub(),
Fragment.CreateNamed("returnFragmentType"),
new List <ReturnCondition>(),
blacklistManager,
delegate { });
StatementHandlerBase <AssignmentStatement> handler = new AssignmentStatementHandlerController(blockParserContext);
Method sampleMethod = IntrospectionUtility.MethodFactory <StatementHandlerBaseSample> ("ContainsReturnStatement");
Block sampleBlock = (Block)sampleMethod.Body.Statements[1];
Statement sample = sampleBlock.Statements[0];
ISymbolTable symbolTable = mocks.Stub <ISymbolTable>();
HandleContext context = new HandleContext(
sample,
symbolTable,
new List <IPreCondition>(),
new List <string>(),
new List <BlockAssignment>(),
new List <int>(),
new Dictionary <string, bool>(),
new Dictionary <string, bool>());
handler.Handle(context);
}
public WeightSettingsWindow(HandleContext windowContext)
{
this.windowContext = windowContext;
this.absorbInputAroundWindow = true;
this.closeOnClickedOutside = false;
this.onlyOneOfTypeAllowed = true;
switch (windowContext)
{
case HandleContext.GENERAL:
windowTitle = "PawnkindRaceDiversity_WeightWindowTitle_FlatWeights";
windowDesc = "PawnkindRaceDiversity_WeightWindowDesc_FlatWeights";
break;
case HandleContext.WORLD:
windowTitle = "PawnkindRaceDiversity_WeightWindowTitle_FlatWeightsPerWorldGen";
windowDesc = "PawnkindRaceDiversity_WeightWindowDesc_FlatWeightsPerWorldGen";
break;
case HandleContext.STARTING:
windowTitle = "PawnkindRaceDiversity_WeightWindowTitle_FlatWeightsStartingPawns";
windowDesc = "PawnkindRaceDiversity_WeightWindowDesc_FlatWeightsStartingPawns";
break;
case HandleContext.LOCAL:
windowTitle = "PawnkindRaceDiversity_WeightWindowTitle_FlatWeightsLocal";
windowDesc = "PawnkindRaceDiversity_WeightWindowDesc_FlatWeightsLocal";
break;
}
windowHandles = ModSettingsHandler.allHandleReferences;
EvaluateWhichDefsAreAdjusted();
}
public async Task BarHandleFooErrorsTest()
{
// arrange
var configuration = new Dictionary <string, IHandlerBehavior>
{
{ "Foo", new HandlerBehavior() },
{
"Bar", new HandlerBehavior
{
Mode = HandleMode.OnError,
}
},
};
var barMock = new Mock <BarHandler>();
var context = new HandleContext <string>("It will fail");
barMock.Setup(b => b.Handle(context)).ReturnsAsync(new HandleResult());
_kernel.Bind <IHandler <string> >().To <FooHandler>().Named("Foo");
_kernel.Bind <IHandler <string> >().ToMethod(ctx => barMock.Object).Named("Bar");
_pipeline.Configure(configuration);
// act
var result = await _pipeline.Execute(context).ConfigureAwait(false);
// assert
result.Success.Should().BeFalse();
result.Errors.Should().HaveCount(1);
barMock.Verify(b => b.HandleError(context));
}
public override void Handle(HandleContext context)
{
var p = context.Packet;
if (p == null)
{
return;
}
Console.WriteLine("{0}({1})", p, p.GetType().Name);
}
internal static void ResetHandle(ref Dictionary <string, float> handle, HandleContext context)
{
Dictionary <string, float> hcopy = new Dictionary <string, float>(handle);
foreach (string key in hcopy.Keys)
{
handle[key] = -1.0f;
}
UpdateHandleReferencesInAllReferences(ref handle, context);
}
protected override void HandleStatement(HandleContext context)
{
AssignmentStatement assignmentStatement = (AssignmentStatement) context.Statement;
if (!CoversAssignment (assignmentStatement))
return;
var target = (Local) assignmentStatement.Target;
context.ArrayFragmentTypeDefined[target.Name.Name] = false;
context.AssignmentTargetVariables.Add (target.Name.Name);
}
private void AddBlockAssignment(AssignmentStatement assignmentStatement, HandleContext context)
{
string targetSymbol = IntrospectionUtility.GetVariableName(assignmentStatement.Target);
string sourceSymbol = IntrospectionUtility.GetVariableName(assignmentStatement.Source);
if (targetSymbol != null && sourceSymbol != null)
{
BlockAssignment blockAssignment = new BlockAssignment(sourceSymbol, targetSymbol);
context.BlockAssignments.Add(blockAssignment);
}
}
public async IAsyncEnumerable <TMessageResult> Mediate(TMessage message,
IMessageContext messageContext)
{
if (messageContext.Handlers.Count > 1)
{
throw new MultipleHandlerFoundException(typeof(TMessage));
}
var handleContext = new HandleContext(message, _cancellationToken);
var result = AsyncEnumerable.Empty <TMessageResult>();
try
{
await messageContext.RunPreHandlers(handleContext);
var handler = messageContext.Handlers.Single().Value;
result = (IAsyncEnumerable <TMessageResult>)handler !.Handle(handleContext);
}
catch (Exception e)
{
if (messageContext.ErrorHandlers.Count + messageContext.IndirectErrorHandlers.Count == 0)
{
throw;
}
handleContext.Exception = e;
await messageContext.RunErrorHandlers(handleContext);
}
await foreach (var messageResult in result.WithCancellation(_cancellationToken))
{
yield return(messageResult);
}
handleContext.MessageResult = result;
try
{
await messageContext.RunPostHandlers(handleContext);
}
catch (Exception e)
{
if (messageContext.ErrorHandlers.Count + messageContext.IndirectErrorHandlers.Count == 0)
{
throw;
}
handleContext.Exception = e;
await messageContext.RunErrorHandlers(handleContext);
}
}
public static async Task RunPreHandlers(this IMessageContext messageContext, HandleContext handleContext)
{
foreach (var preHandler in messageContext.IndirectPreHandlers)
{
await preHandler.Value.PreHandleAsync(handleContext);
}
foreach (var preHandler in messageContext.PreHandlers)
{
await preHandler.Value.PreHandleAsync(handleContext);
}
}
public static async Task RunErrorHandlers(this IMessageContext messageContext, HandleContext handleContext)
{
foreach (var errorHandler in messageContext.IndirectErrorHandlers)
{
await errorHandler.Value.HandleErrorAsync(handleContext);
}
foreach (var errorHandler in messageContext.ErrorHandlers)
{
await errorHandler.Value.HandleErrorAsync(handleContext);
}
}
private Fragment FirstOperandsFragmentType(AssignmentStatement assignment, HandleContext context)
{
Fragment fragmentType = Fragment.CreateEmpty();
Expression firstOperand = FirstOperand(assignment.Source);
if (firstOperand != null)
{
ISymbolTable symbolTable = context.SymbolTable;
fragmentType = symbolTable.InferFragmentType(firstOperand);
}
return(fragmentType);
}
protected override void HandleStatement(HandleContext context)
{
AssignmentStatement assignmentStatement = (AssignmentStatement)context.Statement;
if (!CoversAssignment(assignmentStatement))
{
return;
}
var target = (Local)assignmentStatement.Target;
context.ArrayFragmentTypeDefined[target.Name.Name] = false;
context.AssignmentTargetVariables.Add(target.Name.Name);
}
public float GrabWeightReference(string race, HandleContext context, bool returnNegative = false)
{
string fullID = ModSettingsHandler.GetRaceSettingWeightID(context, race);
if (fullID != null)
{
SettingHandle <float> handle = windowHandles.FirstOrFallback(h => h.Name == fullID, null);
if (handle != null)
{
if ((prevAdjustedRaces[race] && windowContext == context) ||
(handle.Value < 0.0f && windowContext != context))
{
if (returnNegative)
{
return(-1.0f);
}
switch (context)
{
case HandleContext.STARTING:
return(GrabWeightReference(race, HandleContext.WORLD));
case HandleContext.WORLD:
case HandleContext.LOCAL:
//This is performed so that it can also return the human's race setting
return(GrabWeightReference(race, HandleContext.GENERAL));
case HandleContext.GENERAL:
KeyValuePair <string, RaceDiversificationPool> data = racesDiversified.FirstOrFallback(r => r.Key == race);
if (data.Key != null)
{
return(data.Value.flatGenerationWeight);
}
break;
}
}
//This does not display negatives (checkbox will check for that instead)
if (handle.Value >= 0.0f)
{
return(handle.Value);
}
else
{
return(0.0f);
}
}
}
return(0.0f);
}
protected override void HandleStatement(HandleContext context)
{
IStatementHandler selectedHandler;
Func <AssignmentStatementHandlerBase, bool> handlerFilter = handler => handler.Covers(context.Statement);
if (_specificHandlers.Any(handlerFilter))
{
selectedHandler = _specificHandlers.Single(handlerFilter);
}
else
{
selectedHandler = _defaultAssignmentStatementHandler;
}
selectedHandler.Handle(context);
}
public override async void Handle(HandleContext context)
{
HttpRequest request = context.Packet as HttpRequest;
if (request == null)
{
return;
}
HttpResponse response = Handle(request);
await context.Session.SendAsync(response);
await context.Session.Close();
}
private void CheckAssignment(AssignmentStatement assignmentStatement, string targetName, HandleContext context)
{
ISymbolTable symbolTable = context.SymbolTable;
Fragment targetFragmentType = symbolTable.GetFragmentType (targetName);
Fragment sourceFragmentType = symbolTable.InferFragmentType (assignmentStatement.Source);
if (targetFragmentType != sourceFragmentType)
{
symbolTable.MakeUnsafe (targetName);
}
else
{
SetPreConditionForIndexerObject (assignmentStatement, targetName, sourceFragmentType, context);
}
}
protected override void HandleStatement(HandleContext context)
{
AssignmentStatement assignmentStatement = (AssignmentStatement) context.Statement;
if(!CoversAssignment(assignmentStatement))
return;
Method assignedMethod = GetAssignedDelegateMethod (assignmentStatement);
DelegateNode sourceDelegateType = (DelegateNode) assignmentStatement.Source.Type;
Fragment returnFragment = GetDelegateTypesReturnFragment (sourceDelegateType);
ISymbolTable environment = GetDelegatesEnvironment (sourceDelegateType);
IMethodGraphAnalyzer methodParser = new MethodGraphAnalyzer (_blockParserContext.ProblemPipe);
IMethodGraphBuilder methodGraphBuilder = new MethodGraphBuilder (assignedMethod, _blockParserContext.BlacklistManager, _blockParserContext.ProblemPipe, returnFragment);
IInitialSymbolTableBuilder parameterSymbolTableBuilder = new EmbeddedInitialSymbolTableBuilder (assignedMethod, _blockParserContext.BlacklistManager, environment);
methodParser.Parse (methodGraphBuilder, parameterSymbolTableBuilder);
}
internal static string GetRaceSettingWeightID(HandleContext context, string race)
{
switch (context)
{
case HandleContext.GENERAL:
return("flatGenerationWeight_" + race);
case HandleContext.WORLD:
return("flatGenerationWeightPerWorld_" + race);
case HandleContext.STARTING:
return("flatGenerationWeightStartingPawns_" + race);
case HandleContext.LOCAL:
return("flatGenerationWeightLocal_" + race);
}
return(null);
}
private void InferArrayFragment(AssignmentStatement assignmentStatement, string targetName, HandleContext context)
{
ISymbolTable symbolTable = context.SymbolTable;
Fragment targetFragmentType = symbolTable.InferFragmentType (assignmentStatement.Source);
if (context.ArrayFragmentTypeDefined[targetName] == false)
{
symbolTable.MakeSafe(targetName, targetFragmentType);
context.ArrayFragmentTypeDefined[targetName] = true;
}
else if (symbolTable.GetFragmentType(targetName) == Fragment.CreateLiteral())
{
symbolTable.MakeSafe(targetName, targetFragmentType);
}
else if (symbolTable.GetFragmentType(targetName) != targetFragmentType && targetFragmentType != Fragment.CreateLiteral())
{
symbolTable.MakeUnsafe(targetName);
}
}
protected override void HandleStatement(HandleContext context)
{
AssignmentStatement assignmentStatement = (AssignmentStatement) context.Statement;
if(!CoversAssignment(assignmentStatement))
return;
Indexer targetIndexer = (Indexer) assignmentStatement.Target;
string targetName = IntrospectionUtility.GetVariableName (targetIndexer.Object);
if (context.ArrayFragmentTypeDefined.ContainsKey (targetName))
{
InferArrayFragment(assignmentStatement, targetName, context);
}
else
{
CheckAssignment(assignmentStatement, targetName, context);
}
_blockParserContext.Inspect (assignmentStatement.Source);
}
private void OnMessageReceived(object sender, DLB.EventBus.Transport.Messages.TransportMessage e)
{
var handler = _subscribers.FirstOrDefault(p => p.Topic == e.Topic);
string jsonStr = Encoding.UTF8.GetString(e.Body);
if (!string.IsNullOrEmpty(jsonStr))
{
// Message received context
var context = new HandleContext(_consumerClient, e.Headers);
var method = handler.GetType().GetMethod(HandleAsyncMethod);
// Get only dynamic parameter, type of IntegrationEventData
var type = method.GetParameters().FirstOrDefault().ParameterType;
var data = JsonConvert.DeserializeObject(jsonStr, type);
object[] parametersArray = new object[] { data, context, this };
method.Invoke(handler, parametersArray);
}
}
private void Inspect(Block methodBodyBlock)
{
foreach (Statement statement in methodBodyBlock.Statements)
{
if (_statementHandlers.ContainsKey(statement.GetType()))
{
HandleContext context = new HandleContext(
statement,
_symbolTableParser,
_preConditions,
_assignmentTargetVariables,
_blockAssignments,
_successors,
_locallyInitializedArrays,
_stringBuilderFragmentTypesDefined);
_statementHandlers[statement.GetType()].Handle(context);
}
}
}
protected override void HandleStatement(HandleContext context)
{
AssignmentStatement assignmentStatement = (AssignmentStatement)context.Statement;
if (!CoversAssignment(assignmentStatement))
{
return;
}
Method assignedMethod = GetAssignedDelegateMethod(assignmentStatement);
DelegateNode sourceDelegateType = (DelegateNode)assignmentStatement.Source.Type;
Fragment returnFragment = GetDelegateTypesReturnFragment(sourceDelegateType);
ISymbolTable environment = GetDelegatesEnvironment(sourceDelegateType);
IMethodGraphAnalyzer methodParser = new MethodGraphAnalyzer(_blockParserContext.ProblemPipe);
IMethodGraphBuilder methodGraphBuilder = new MethodGraphBuilder(assignedMethod, _blockParserContext.BlacklistManager, _blockParserContext.ProblemPipe, returnFragment);
IInitialSymbolTableBuilder parameterSymbolTableBuilder = new EmbeddedInitialSymbolTableBuilder(assignedMethod, _blockParserContext.BlacklistManager, environment);
methodParser.Parse(methodGraphBuilder, parameterSymbolTableBuilder);
}
protected override void HandleStatement(HandleContext context)
{
AssignmentStatement assignment = (AssignmentStatement) context.Statement;
if(!CoversAssignment(assignment))
return;
Method sourceConstructor = ExtractConstructor (assignment.Source);
string variableName = IntrospectionUtility.GetVariableName (assignment.Target);
bool fragmentTypeInferenceRequired = FirstParameterIsString (sourceConstructor);
if (fragmentTypeInferenceRequired)
{
Fragment fragmentType = FirstOperandsFragmentType(assignment, context);
context.StringBuilderFragmentTypeDefined[variableName] = true;
context.SymbolTable.MakeSafe (variableName, fragmentType);
}
else
{
//context.StringBuilderFragmentTypeDefined[variableName] = false;
context.SymbolTable.MakeSafe (variableName, Fragment.CreateUndefined());
}
}
public void HandleStatement_InitializationWithEmptyConstructor_VariableFragmentTypeIsNull()
{
Method sampleMethod = IntrospectionUtility.MethodFactory <StringBuilderConstructStatementHandlerSample> ("InitializationWithEmptyConstructor");
Block sampleBlock = (Block)sampleMethod.Body.Statements[0];
Statement sample = sampleBlock.Statements[1];
HandleContext context = new HandleContext(
sample,
_symbolTable,
new List <IPreCondition>(),
new List <string>(),
new List <BlockAssignment>(),
new List <int>(),
new Dictionary <string, bool>(),
_stringBuilderFragmentTypesDefined);
_handler.Handle(context);
bool variableUndefined = _symbolTable.GetFragmentType("local$0").Undefined;
Assert.That(variableUndefined, Is.True);
}
public void HandleStatement_NonStringBuilderAssignment_VariableNotMapped()
{
Method sampleMethod = IntrospectionUtility.MethodFactory <StringBuilderConstructStatementHandlerSample> ("NonStringBuilderAssignment");
Block sampleBlock = (Block)sampleMethod.Body.Statements[0];
Statement sample = sampleBlock.Statements[1];
HandleContext context = new HandleContext(
sample,
_symbolTable,
new List <IPreCondition>(),
new List <string>(),
new List <BlockAssignment>(),
new List <int>(),
new Dictionary <string, bool>(),
_stringBuilderFragmentTypesDefined);
_handler.Handle(context);
bool variableAdded = _stringBuilderFragmentTypesDefined.ContainsKey("local$0");
Assert.That(variableAdded, Is.False);
}
public void HandleStatement_InitializationWithFragmentAndInts_VariableFragmentTypeIsFragment()
{
Method sampleMethod = IntrospectionUtility.MethodFactory <StringBuilderConstructStatementHandlerSample> ("InitializationWithFragmentAndInts");
Block sampleBlock = (Block)sampleMethod.Body.Statements[0];
Statement sample = sampleBlock.Statements[1];
HandleContext context = new HandleContext(
sample,
_symbolTable,
new List <IPreCondition>(),
new List <string>(),
new List <BlockAssignment>(),
new List <int>(),
new Dictionary <string, bool>(),
_stringBuilderFragmentTypesDefined);
_handler.Handle(context);
bool symbolTableEntryCorrect = _symbolTable.GetFragmentType("local$0") == Fragment.CreateNamed("StringBuilderFragment");
Assert.That(symbolTableEntryCorrect, Is.True);
}
private async Task OnMessageReceivedAsync(object sender, DLB.EventBus.Transport.Messages.TransportMessage e)
{
using (var scope = _serviceScopeFactory.CreateScope())
{
var subscribers = scope.ServiceProvider.GetService <IEnumerable <ISubscriber> >();
string jsonStr = Encoding.UTF8.GetString(e.Body);
var handlerList = subscribers.Where(p => p.Topic == e.Topic);
if (!string.IsNullOrEmpty(jsonStr) && handlerList != null && handlerList.Any())
{
// Message received context
var context = new HandleContext(_consumerClient, e);
foreach (var handler in handlerList)
{
// Get only dynamic parameter, type of IntegrationEventData
var method = handler.GetType().GetMethod(HandleAsyncMethod);
var type = method.GetParameters().FirstOrDefault().ParameterType;
var headerType = e.Headers[Messages.Headers.Type];
if (headerType == type.Name)
{
// If no throw exception we found a valid handler
var data = JsonConvert.DeserializeObject(jsonStr, type, this._options.JsonSerializerSettings);
object[] parametersArray = new object[] { data, context, this };
var task = (Task)method.Invoke(handler, parametersArray);
await task.ConfigureAwait(false);
break;
}
}
}
}
}
protected override void HandleStatement(HandleContext context)
{
AssignmentStatement assignmentStatement = (AssignmentStatement)context.Statement;
string targetSymbol = IntrospectionUtility.GetVariableName(assignmentStatement.Target);
context.AssignmentTargetVariables.Add(targetSymbol);
string sourceSymbol = IntrospectionUtility.GetVariableName(assignmentStatement.Source);
bool localSourceVariableNotAssignedInsideCurrentBlock =
sourceSymbol != null &&
!context.AssignmentTargetVariables.Contains(sourceSymbol) &&
!IntrospectionUtility.IsField(assignmentStatement.Source);
bool targetIsField = IntrospectionUtility.IsField(assignmentStatement.Target);
if (localSourceVariableNotAssignedInsideCurrentBlock)
{
if (targetIsField)
{
AddAssignmentPreCondition(assignmentStatement, context);
}
else
{
AddBlockAssignment(assignmentStatement, context);
}
}
else
{
if (targetIsField)
{
ValidateAssignmentOnField(assignmentStatement, context);
}
else
{
context.SymbolTable.InferSafeness(targetSymbol, assignmentStatement.Source);
}
}
_blockParserContext.Inspect(assignmentStatement.Source);
}
protected override void HandleStatement(HandleContext context)
{
AssignmentStatement assignmentStatement = (AssignmentStatement)context.Statement;
if (!CoversAssignment(assignmentStatement))
{
return;
}
Indexer targetIndexer = (Indexer)assignmentStatement.Target;
string targetName = IntrospectionUtility.GetVariableName(targetIndexer.Object);
if (context.ArrayFragmentTypeDefined.ContainsKey(targetName))
{
InferArrayFragment(assignmentStatement, targetName, context);
}
else
{
CheckAssignment(assignmentStatement, targetName, context);
}
_blockParserContext.Inspect(assignmentStatement.Source);
}
public async Task <TMessageResult> Mediate(TMessage message,
IMessageContext messageContext)
{
if (messageContext.Handlers.Count > 1)
{
throw new MultipleHandlerFoundException(typeof(TMessage));
}
var handleContext = new HandleContext(message, _cancellationToken);
TMessageResult result = default;
try
{
await messageContext.RunPreHandlers(handleContext);
var handler = messageContext.Handlers.Single().Value;
result = await(Task <TMessageResult>) handler !.Handle(handleContext);
handleContext.MessageResult = result;
await messageContext.RunPostHandlers(handleContext);
}
catch (Exception e)
{
if (messageContext.ErrorHandlers.Count + messageContext.IndirectErrorHandlers.Count == 0)
{
throw;
}
handleContext.Exception = e;
await messageContext.RunErrorHandlers(handleContext);
}
return(result);
}
private void SetPreConditionForIndexerObject(
AssignmentStatement assignmentStatement, string targetName, Fragment sourceFragmentType, HandleContext context)
{
if (targetName != null)
{
ProblemMetadata problemMetadata = new ProblemMetadata (
assignmentStatement.UniqueKey,
assignmentStatement.SourceContext,
sourceFragmentType,
Fragment.CreateNamed ("??"));
var preCondition = new EqualityPreCondition (targetName, sourceFragmentType, problemMetadata);
context.PreConditions.Add (preCondition);
}
}
private Fragment FirstOperandsFragmentType(AssignmentStatement assignment, HandleContext context)
{
Fragment fragmentType = Fragment.CreateEmpty();
Expression firstOperand = FirstOperand (assignment.Source);
if (firstOperand != null)
{
ISymbolTable symbolTable = context.SymbolTable;
fragmentType = symbolTable.InferFragmentType(firstOperand);
}
return fragmentType;
}
private void SetPreConditionForIndexerObject(
AssignmentStatement assignmentStatement, string targetName, Fragment sourceFragmentType, HandleContext context)
{
if (targetName != null)
{
ProblemMetadata problemMetadata = new ProblemMetadata(
assignmentStatement.UniqueKey,
assignmentStatement.SourceContext,
sourceFragmentType,
Fragment.CreateNamed("??"));
var preCondition = new EqualityPreCondition(targetName, sourceFragmentType, problemMetadata);
context.PreConditions.Add(preCondition);
}
}
public virtual void Process(CronusMessage message)
{
var context = new HandleContext(message, handlerType);
handlerWorkflow.Run(context);
}
