private static void GetContinueWorkDay(IEnumerable <AssignmentBase> assignments, Action <DateTime, DateTime> workDelegate)
{
AssignmentBase previousAssignment = null;
AssignmentBase headAssignment = null;
foreach (var item in assignments)
{
//在排班期內找出所有>=24小時的空檔. (排班期起訖要外擴x日)
if (previousAssignment != null && previousAssignment.End.AddDays(1) <= item.Start &&
previousAssignment.Start.Date != item.Start.Date)
{
workDelegate(headAssignment.Start, previousAssignment.End);
headAssignment = item;
}
if (headAssignment == null)
{
headAssignment = item;
}
previousAssignment = item;
}
//判断边界
if (previousAssignment != null && headAssignment != previousAssignment)
{
workDelegate(headAssignment.Start, previousAssignment.End);
}
}
private static void GetContinueDayOff(DateRange boundary, IEnumerable <AssignmentBase> assignments, Action <DateTime, DateTime> gapDelegate)
{
var firstAssignment = assignments.FirstOrDefault();
var endAssignment = assignments.LastOrDefault();
//for Assignment < Schedule.Start || Assignment >Schedule.End
var start = firstAssignment == null || firstAssignment.Start >= boundary.Start ? boundary.Start : firstAssignment.Start;
var end = endAssignment == null || endAssignment.Start <= boundary.End ? boundary.End : endAssignment.Start;
if (firstAssignment == null)
{
gapDelegate(start, end.AddDays(-1));
return;
}
AssignmentBase lastAssignment = null;
foreach (var item in assignments)
{
if (item.AsAWork)
{
if (lastAssignment != null && lastAssignment.Start.Date != item.Start.Date.AddDays(-1) &&
lastAssignment.Start.Date != item.Start.Date)
{
gapDelegate(lastAssignment.Start.Date.AddDays(1), item.Start.Date.AddDays(-1));
}
if (lastAssignment == null)
{
if (item.Start.Date == start.Date)
{
lastAssignment = item;
continue;
}
gapDelegate(start.Date, item.Start.Date.AddDays(-1));
}
lastAssignment = item;
}
}
if (lastAssignment != null && lastAssignment.Start.Date < end.Date.AddDays(-1))
{
gapDelegate(lastAssignment.Start.Date.AddDays(1), end.Date.AddDays(-1));
}
}
private static void GetAssignmentGaps(IEnumerable <AssignmentBase> assignments, TimeSpan minIdleGap, Action <DateRange> gapDelegate)
{
var dateRanges = new List <DateRange>();
AssignmentBase previousAssignment = null;
AssignmentBase headAssignment = null;
foreach (var item in assignments.OrderBy(o => o.Start))
{
//在排班期內找出所有<最小班距的空檔---IllegalGap
if (previousAssignment != null && item.From.Subtract(previousAssignment.Finish) < minIdleGap)
{
dateRanges.Add(new DateRange(previousAssignment.From, item.Finish));
headAssignment = item;
}
if (headAssignment == null)
{
headAssignment = item;
}
previousAssignment = item;
}
if (dateRanges.Count != 0)
{
var start = dateRanges[0].Start;
var end = dateRanges[0].End;
for (var i = 0; i < dateRanges.Count; i++)
{
if (i == dateRanges.Count - 1)
{
end = dateRanges[i].End;
gapDelegate(new DateRange(start, end));
}
else
{
if (end > dateRanges[i + 1].Start)
{
end = dateRanges[i + 1].End;
}
else
{
gapDelegate(new DateRange(start, end));
start = dateRanges[i + 1].Start;
end = dateRanges[i + 1].End;
}
}
}
}
}
public bool ApplyAbsent(IAgent agent, AssignmentBase assignment, TermStyle type, TimeSpan length)
{
TermAlteringListener.Manually();
var newAbsent = new AbsentEvent(assignment.Start, length, type);
var success = false;
agent.Schedule.Create(newAbsent,
(t, result) =>
{
success = result;
//if (success)
// assignment.OccupyStatus = "A";
}, false);
return(success);
}
private void ProcessAssignment(
[NotNull] GraphDataFlowExpressionNode node,
[NotNull] AssignmentBase assignmentBase,
[NotNull] GraphNode[] path)
{
IValue left = assignmentBase.Left;
var right = assignmentBase.Right;
left = node.EnterAnalysisContext[left];
if (left == null)
{
Log.Warning("Skipping {Assignment} since LHS expression resolved to null", assignmentBase);
return;
}
var leftVariant = left is ValueVariantBase leftOldVariableVariant
? leftOldVariableVariant
: throw new ArgumentOutOfRangeException(nameof(left));
leftVariant = leftVariant.Clone(node.EnterAnalysisContext, path);
var implemented = false;
switch (assignmentBase)
{
case OperatorAssignment operatorAssignment:
{
var @operator = operatorAssignment.Operator;
switch (@operator)
{
case BinaryPureBase binaryPureBase:
{
var interval = binaryPureBase.ApplyPossibleVariants(leftVariant, right);
if (interval != null)
{
leftVariant.Value = new DataValueInterval(interval, leftVariant.Value.Constraints);
implemented = true;
}
break;
}
case UnaryPureBase unaryPureBase:
goto default;
default:
throw new ArgumentOutOfRangeException(nameof(@operator));
}
break;
}
case SimpleAssignment _:
{
var interval = node.EnterAnalysisContext.ResolveToRange(right);
if (interval != null)
{
leftVariant.Value = new DataValueInterval(interval, Array.Empty <LogicExpressionBase>());
implemented = true;
}
break;
}
default:
throw new ArgumentOutOfRangeException(nameof(assignmentBase));
}
if (!implemented)
{
Log.Information("Assignment: ({LeftKind}) {Operator} ({RightKind})",
left.GetType().Name,
assignmentBase,
right?.GetType().Name);
return;
}
node.ExitAnalysisContext[leftVariant] = leftVariant;
}
public static string AssigmentToVHDL(AssignmentBase assignment)
{
return(" " + assignment.LeftSide.Text + " => " + assignment.RightSide.Text);
}
public bool ApplyAbsent(IAgent agent, AssignmentBase assignment, TermStyle type, TimeSpan length)
{
TermAlteringListener.Manually();
var newAbsent = new AbsentEvent(assignment.Start, length, type);
var success = false;
agent.Schedule.Create(newAbsent,
(t, result) =>
{
success = result;
//if (success)
// assignment.OccupyStatus = "A";
}, false);
return success;
}
public AssignmentSideBase(AssignmentBase assignment, string text)
{
Assignment = assignment;
Text = text;
}
private static List <ExpressionBase> ConvertRoslynExpressionToWandaExpression(
SimpleCompoundStatement wandaBlock,
ExpressionSyntax expressionSyntax)
{
var result = new List <ExpressionBase>();
switch (expressionSyntax)
{
case AssignmentExpressionSyntax assignmentExpressionSyntax:
{
var left = assignmentExpressionSyntax.Left;
var operatorToken = assignmentExpressionSyntax.OperatorToken;
var right = assignmentExpressionSyntax.Right;
var leftValue = wandaBlock.ResolveLValue(result, left, true);
var rightValue = wandaBlock.ResolveValue(result, right, true);
AssignmentBase assignment = null;
switch (operatorToken.Kind())
{
case SyntaxKind.EqualsToken:
assignment = new SimpleAssignment(leftValue, rightValue);
break;
case SyntaxKind.SlashEqualsToken:
assignment = new OperatorAssignment(leftValue, rightValue, BinaryDivideOperator.Instance);
break;
case SyntaxKind.PlusEqualsToken:
assignment = new OperatorAssignment(leftValue, rightValue, BinaryAddOperator.Instance);
break;
case SyntaxKind.MinusEqualsToken:
assignment = new OperatorAssignment(leftValue, rightValue, BinarySubtractOperator.Instance);
break;
case SyntaxKind.AsteriskEqualsToken:
assignment = new OperatorAssignment(leftValue, rightValue, BinaryMultiplyOperator.Instance);
break;
case SyntaxKind.PercentEqualsToken:
assignment =
new OperatorAssignment(leftValue, rightValue, BinaryRemainderOperator.Instance);
break;
case SyntaxKind.AmpersandEqualsToken:
assignment = new OperatorAssignment(leftValue, rightValue, BinaryBitAndOperator.Instance);
break;
case SyntaxKind.CaretEqualsToken:
assignment = new OperatorAssignment(leftValue, rightValue, BinaryBitXorOperator.Instance);
break;
case SyntaxKind.BarEqualsToken:
assignment = new OperatorAssignment(leftValue, rightValue, BinaryBitOrOperator.Instance);
break;
case SyntaxKind.LessThanLessThanEqualsToken:
assignment = new OperatorAssignment(leftValue, rightValue,
BinaryBitShiftLeftOperator.Instance);
break;
case SyntaxKind.GreaterThanGreaterThanEqualsToken:
assignment = new OperatorAssignment(leftValue, rightValue,
BinaryBitShiftRightOperator.Instance);
break;
case SyntaxKind.QuestionQuestionEqualsToken:
break;
default:
throw new ArgumentOutOfRangeException();
}
if (assignment != null)
{
result.Add(assignment);
}
else
{
Log.Debug("{Left} {Operator} {Right}", left,
operatorToken.Text,
right);
}
break;
}
case PrefixUnaryExpressionSyntax unaryExpressionSyntax:
{
var operand = unaryExpressionSyntax.Operand;
var leftValue = wandaBlock.ResolveLValue(result, operand, true);
AssignmentBase assignment = null;
var operatorToken = unaryExpressionSyntax.OperatorToken;
switch (operatorToken.Kind())
{
case SyntaxKind.PlusToken:
case SyntaxKind.MinusToken:
case SyntaxKind.TildeToken:
case SyntaxKind.ExclamationToken:
break;
case SyntaxKind.PlusPlusToken:
assignment = new OperatorAssignment(leftValue, IntegerLiteral.One,
BinaryAddOperator.Instance);
break;
case SyntaxKind.MinusMinusToken:
assignment = new OperatorAssignment(leftValue, IntegerLiteral.One,
BinarySubtractOperator.Instance);
break;
case SyntaxKind.AmpersandToken:
case SyntaxKind.AsteriskToken:
case SyntaxKind.CaretToken:
break;
default:
throw new ArgumentOutOfRangeException();
}
if (assignment != null)
{
result.Add(assignment);
}
else
{
Log.Debug("{Operator} {Right}", operatorToken.Text,
unaryExpressionSyntax.Operand);
}
break;
}
case PostfixUnaryExpressionSyntax unaryExpressionSyntax:
{
var operand = unaryExpressionSyntax.Operand;
var leftValue = wandaBlock.ResolveLValue(result, operand, true);
AssignmentBase assignment = null;
var operatorToken = unaryExpressionSyntax.OperatorToken;
switch (operatorToken.Kind())
{
case SyntaxKind.PlusPlusToken:
assignment = new OperatorAssignment(leftValue, IntegerLiteral.One,
BinaryAddOperator.Instance);
break;
case SyntaxKind.MinusMinusToken:
assignment = new OperatorAssignment(leftValue, IntegerLiteral.One,
BinarySubtractOperator.Instance);
break;
case SyntaxKind.ExclamationToken:
break;
default:
throw new ArgumentOutOfRangeException();
}
if (assignment != null)
{
// todo: that's not right. The value returned by expression is not as simple
result.Add(assignment);
}
else
{
Log.Debug("{Left} {Operator}", unaryExpressionSyntax.Operand,
operatorToken.Text);
}
break;
}
case InvocationExpressionSyntax invocationExpressionSyntax:
{
var what = invocationExpressionSyntax.Expression.ToString();
FunctionCallParameter Selector(ArgumentSyntax x)
{
var xRefKindKeyword = x.RefKindKeyword.Kind();
var(isRef, isOut) = (
xRefKindKeyword == SyntaxKind.RefKeyword,
xRefKindKeyword == SyntaxKind.OutKeyword);
return(new FunctionCallParameter
{
Value = wandaBlock.ResolveValue(result, x.Expression, true),
Out = isOut,
Ref = isRef
});
}
var with = invocationExpressionSyntax.ArgumentList.Arguments.Select(Selector);
var functionCallOperator = new FunctionCallOperator {
Name = what
};
functionCallOperator.Arguments.AddRange(with);
result.Add(functionCallOperator);
break;
}
case IdentifierNameSyntax identifierNameSyntax:
{
result.Add(wandaBlock.ResolveVariableByName(identifierNameSyntax.Identifier.Text));
break;
}
case LiteralExpressionSyntax literalExpressionSyntax:
{
result.Add(ResolveLiteral(literalExpressionSyntax));
break;
}
case ElementAccessExpressionSyntax elementAccessExpressionSyntax:
{
result.Add(
ResolveRoslynElementAccessExpressionToWandaOperator(elementAccessExpressionSyntax,
result,
wandaBlock));
break;
}
case BinaryExpressionSyntax binaryExpressionSyntax:
{
var operatorToken = binaryExpressionSyntax.OperatorToken;
PureBase operatorBase = null;
LogicBase logicBase = null;
switch (operatorToken.Kind())
{
case SyntaxKind.PlusToken:
operatorBase = BinaryAddOperator.Instance;
break;
case SyntaxKind.MinusToken:
operatorBase = BinarySubtractOperator.Instance;
break;
case SyntaxKind.AsteriskToken:
operatorBase = BinaryMultiplyOperator.Instance;
break;
case SyntaxKind.SlashToken:
operatorBase = BinaryDivideOperator.Instance;
break;
case SyntaxKind.PercentToken:
operatorBase = BinaryRemainderOperator.Instance;
break;
case SyntaxKind.LessThanLessThanToken:
operatorBase = BinaryBitShiftLeftOperator.Instance;
break;
case SyntaxKind.GreaterThanGreaterThanToken:
operatorBase = BinaryBitShiftRightOperator.Instance;
break;
case SyntaxKind.BarBarToken:
logicBase = OrLogic.Instance;
break;
case SyntaxKind.AmpersandAmpersandToken:
logicBase = AndLogic.Instance;
break;
case SyntaxKind.BarToken:
operatorBase = BinaryBitOrOperator.Instance;
break;
case SyntaxKind.AmpersandToken:
operatorBase = BinaryBitAndOperator.Instance;
break;
case SyntaxKind.CaretToken:
operatorBase = BinaryBitXorOperator.Instance;
break;
case SyntaxKind.EqualsEqualsToken:
logicBase = EqualLogic.Instance;
break;
case SyntaxKind.ExclamationEqualsToken:
logicBase = NotEqualLogic.Instance;
break;
case SyntaxKind.LessThanToken:
logicBase = LessLogic.Instance;
break;
case SyntaxKind.LessThanEqualsToken:
logicBase = LessOrEqualLogic.Instance;
break;
case SyntaxKind.GreaterThanToken:
logicBase = GreaterLogic.Instance;
break;
case SyntaxKind.GreaterThanEqualsToken:
logicBase = GreaterOrEqualLogic.Instance;
break;
case SyntaxKind.IsKeyword:
case SyntaxKind.AsKeyword:
case SyntaxKind.QuestionQuestionToken:
break;
default:
throw new ArgumentOutOfRangeException();
}
switch (operatorBase != null, logicBase != null)
{
case (true, false):
{
var left = wandaBlock.ResolveValue(result, binaryExpressionSyntax.Left, true);
var right = wandaBlock.ResolveValue(result, binaryExpressionSyntax.Right, true);
var dummy = new DummyVariable
{
TypeRef = ApproximateResultTypeOfBinaryOperator(left, right)
};
wandaBlock.LocalVariables.Add(dummy);
var assignment = new SimpleAssignment(dummy, left);
result.Add(assignment);
var operatorAssignment = new OperatorAssignment(dummy, right, operatorBase);
result.Add(operatorAssignment);
break;
}
case (false, true):
{
var left = wandaBlock.ResolveValue(result, binaryExpressionSyntax.Left, true);
var right = wandaBlock.ResolveValue(result, binaryExpressionSyntax.Right, true);
var operatorAssignment = new BinaryLogicExpression(logicBase, left, right);
result.Add(operatorAssignment);
break;
}
case (false, false):
{
Log.Debug("BINARY: {Left} {Operator} {Right} ({Kind})",
binaryExpressionSyntax.Left,
operatorToken.Text,
binaryExpressionSyntax.Right,
operatorToken.Kind());
break;
}
default:
throw new ArgumentOutOfRangeException();
}
break;
}
