public LiteralValueNode ParseLitealValue(Token token)
{
if (token.Type == TokenType.LiteralValue)
{
LiteralValueNode value = null;
CobaltType cobaltType = token.GetData <CobaltType>(TokenDataKeys.COBALT_TYPE);
switch (cobaltType)
{
case CobaltType.Boolean:
value = new BooleanValueNode(token.SourceLine, token.GetData <bool>(TokenDataKeys.LITERAL_VALUE));
break;
case CobaltType.Float:
value = new FloatValueNode(token.SourceLine, token.GetData <float>(TokenDataKeys.LITERAL_VALUE));
break;
case CobaltType.Integer:
value = new IntegerValueNode(token.SourceLine, token.GetData <int>(TokenDataKeys.LITERAL_VALUE));
break;
default:
throw new CompilerException($"`{MethodBase.GetCurrentMethod().Name}` called with unknown Cobalt type `{cobaltType}`.");
}
return(value);
}
else
{
throw new CompilerException($"`{MethodBase.GetCurrentMethod().Name}` called with a bad token. Expected a token of type `{TokenType.LiteralValue}`, got token of type `{token.Type}` instead.");
}
}
internal static StreamDirective?GetStreamDirective(
this IReadOnlyList <DirectiveNode> directives,
IVariableValueCollection variables)
{
DirectiveNode?directiveNode =
GetDirective(directives, WellKnownDirectives.Stream);
if (directiveNode is not null)
{
var @if = true;
string?label = null;
var initialCount = 0;
foreach (ArgumentNode argument in directiveNode.Arguments)
{
switch (argument.Name.Value)
{
case WellKnownDirectives.IfArgument:
@if = argument.Value switch
{
VariableNode variable
=> variables.GetVariable <bool>(variable.Name.Value),
BooleanValueNode b => b.Value,
_ => @if
};
break;
case WellKnownDirectives.LabelArgument:
label = argument.Value switch
{
VariableNode variable
=> variables.GetVariable <string?>(variable.Name.Value),
StringValueNode b => b.Value,
_ => label
};
break;
case WellKnownDirectives.InitialCount:
initialCount = argument.Value switch
{
VariableNode variable
=> variables.GetVariable <int>(variable.Name.Value),
IntValueNode b => b.ToInt32(),
_ => initialCount
};
break;
}
}
return(new StreamDirective(@if, initialCount, label));
}
return(null);
}
public void Matrix_Can_Be_Coerced_From_Single_Value()
{
// arrange
var type = (IInputType) new ListType(new ListType(new BooleanType()));
var value = new BooleanValueNode(true);
// act
object coercedValue = type.ParseLiteral(value);
// assert
coercedValue.MatchSnapshot();
}
public void ParseLiteral()
{
// arrange
BooleanValueNode literal = new BooleanValueNode(null, true);
// act
BooleanType booleanType = new BooleanType();
object result = booleanType.ParseLiteral(literal);
// assert
Assert.IsType <bool>(result);
Assert.True((bool)result);
}
public void Matrix_Can_Be_Coerced_From_Single_Value()
{
// arrange
var inputParser = new InputParser(new DefaultTypeConverter());
var type = (IInputType) new ListType(new ListType(new BooleanType()));
var value = new BooleanValueNode(true);
// act
var coercedValue = inputParser.ParseLiteral(value, type, Path.New("root"));
// assert
coercedValue.MatchSnapshot();
}
public void ListCanBeCoercedFromListElementValue()
{
// arrange
var inputParser = new InputParser(new DefaultTypeConverter());
var type = (IInputType) new ListType(new BooleanType());
var element = new BooleanValueNode(true);
// act
var coercedValue = inputParser.ParseLiteral(element, type, Path.New("root"));
// assert
Assert.Collection(Assert.IsType <List <bool?> >(coercedValue), Assert.True);
}
public void ListCanBeCoercedFromListElementValue()
{
// arrange
var type = new ListType(new BooleanType());
var element = new BooleanValueNode(true);
// act
object coercedValue = type.ParseLiteral(element);
// assert
Assert.IsType <bool[]>(coercedValue);
Assert.Collection((bool[])coercedValue,
t => Assert.True(t));
}
public void IsInstanceOfType()
{
// arrange
BooleanValueNode boolLiteral = new BooleanValueNode(null, true);
StringValueNode stringLiteral = new StringValueNode(null, "12345", false);
NullValueNode nullLiteral = NullValueNode.Default;
// act
BooleanType booleanType = new BooleanType();
bool isIntLiteralInstanceOf = booleanType.IsInstanceOfType(boolLiteral);
bool isStringLiteralInstanceOf = booleanType.IsInstanceOfType(stringLiteral);
bool isNullLiteralInstanceOf = booleanType.IsInstanceOfType(nullLiteral);
// assert
Assert.True(isIntLiteralInstanceOf);
Assert.False(isStringLiteralInstanceOf);
Assert.True(isNullLiteralInstanceOf);
}
internal static DeferDirective?GetDeferDirective(
this IReadOnlyList <DirectiveNode> directives,
IVariableValueCollection variables)
{
DirectiveNode?directiveNode =
GetDirective(directives, WellKnownDirectives.Defer);
if (directiveNode is not null)
{
var @if = false;
string?label = null;
foreach (ArgumentNode argument in directiveNode.Arguments)
{
switch (argument.Name.Value)
{
case WellKnownDirectives.IfArgument:
@if = argument.Value switch
{
VariableNode variable =>
variables.GetVariable <BooleanValueNode>(
variable.Name.Value).Value,
BooleanValueNode b => b.Value,
_ => @if
};
break;
case WellKnownDirectives.LabelArgument:
label = argument.Value switch
{
VariableNode variable =>
variables.GetVariable <string?>(variable.Name.Value),
StringValueNode b => b.Value,
_ => label
};
break;
}
}
return(new DeferDirective(@if, label));
}
return(null);
}
public override dynamic Visit(BooleanValueNode node)
{
return(PrimitiveType.Boolean);
}
public abstract dynamic Visit(BooleanValueNode node);
protected override void VisitBooleanValue(
BooleanValueNode node,
Action <object> setValue)
{
setValue(node.Value);
}
protected virtual void VisitBooleanValue(BooleanValueNode node)
{
}
public override dynamic Visit(BooleanValueNode node)
{
return(null);
}
