public override ExpressionSyntax AccessSyntax(CSPort sourcePort)
{
var argumentList = SyntaxFactory.ArgumentList();
foreach (var par in (Symbol as IMethodSymbol).Parameters)
{
if (this.Ports.FirstOrDefault(x => x.Text == par.Name) is CSPort port)
{
if (port.ConnectedPorts.Any())
{
argumentList = argumentList.AddArguments(SyntaxFactory.Argument((port.ConnectedPorts.First() as CSPort).AccessSyntax()));
}
else
{
argumentList = argumentList.AddArguments(SyntaxFactory.Argument(port.AccessSyntax()));
}
}
}
var identifiers = this.Name.Split('.');
var first = string.Join('.', identifiers.SkipLast(1));
var last = identifiers.Last();
return(SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(first), SyntaxFactory.IdentifierName(last))).WithArgumentList(argumentList));
}
public override IEnumerable <StatementSyntax> GetStatementSyntax(CSPort sourcePort)
{
var args = SyntaxFactory.ArgumentList();
//foreach (var par in (Symbol as IMethodSymbol).Parameters)
//{
// if (Ports.FirstOrDefault(x => x.Text == par.Name) is CSPort port)
// {
// if (port.IsConnected)
// {
// args = args.AddArguments(SyntaxFactory.Argument(port.GetFirstConnectedPortMemberAccessExpressionSyntax()));
// }
// else
// {
// args = args.AddArguments(SyntaxFactory.Argument(port.GetValueLiteralExpression()));
// }
// }
//}
var invocation = SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName(Name));
if (args.Arguments.Any())
{
invocation = invocation.WithArgumentList(args);
}
var syntaxNode = SyntaxFactory.ExpressionStatement(invocation);
if (!string.IsNullOrWhiteSpace(Comment))
{
syntaxNode = syntaxNode.WithLeadingTrivia(GetCommentSyntaxTrivia());
}
return(new[] { syntaxNode });
}
public override IEnumerable <StatementSyntax> GetStatementSyntax(CSPort sourcePort)
{
var statements = new List <StatementSyntax>();
var block = SyntaxFactory.Block();
var complete = new List <StatementSyntax>();
var bodyPort = Ports.FirstOrDefault(x => x.HasProperty(BODY_PROPERTY));
var collectionPort = Ports.FirstOrDefault(x => x.HasProperty(COLLECTION_PROPERTY)) as CSPort;
var completePort = Ports.FirstOrDefault(x => x.HasProperty(COMPLETE_PROPERTY)) as CSPort;
foreach (var connectedPort in bodyPort.ConnectedPorts.Cast <CSPort>())
{
block = block.AddStatements(connectedPort.GetStatementSyntax().ToArray());
}
foreach (var connectedPort in completePort.ConnectedPorts.Cast <CSPort>())
{
complete.AddRange(connectedPort.GetStatementSyntax().ToArray());
}
var colRef = collectionPort.GetFirstConnectedPortMemberAccessExpressionSyntax();
if (colRef == null)
{
return(new[] { SyntaxFactory.EmptyStatement() });
//return new[] { SyntaxFactory.ForEachStatement(SyntaxFactory.ParseTypeName("var"), "item", SyntaxFactory.LiteralExpression(SyntaxKind.ExpressionStatement, SyntaxFactory.Literal("collection")), block) };
}
statements.Add(SyntaxFactory.ForEachStatement(SyntaxFactory.ParseTypeName("var"), "item", collectionPort.GetFirstConnectedPortMemberAccessExpressionSyntax(), block));
statements.AddRange(complete);
return(statements);
}
public override ExpressionSyntax AccessSyntax(CSPort sourcePort)
{
if (sourcePort.HasProperty(SET_VALUE_PROPERTY))
{
return(SyntaxFactory.IdentifierName("value"));
}
return(SyntaxFactory.IdentifierName(this.Name));
}
public override IEnumerable <StatementSyntax> GetStatementSyntax(CSPort sourcePort)
{
var returnPort = Ports.FirstOrDefault(x => x.HasProperty(RETURN_ITEM)) as CSPort;
if (returnPort.ConnectedPorts.Any())
{
var result = SyntaxFactory.ReturnStatement(returnPort.GetFirstConnectedPortMemberAccessExpressionSyntax());
return(new[] { result });
}
else
{
return(new[] { SyntaxFactory.ReturnStatement() });
}
}
public override IEnumerable <StatementSyntax> GetStatementSyntax(CSPort sourcePort)
{
var list = new List <StatementSyntax>();
var argumentList = SyntaxFactory.ArgumentList();
//foreach (var par in Symbol.Parameters)
//{
// if (this.Ports.FirstOrDefault(x => x.Text == par.Name) is CSPort port)
// {
// if (port.ConnectedPorts.Any())
// {
// argumentList = argumentList.AddArguments(SyntaxFactory.Argument((port.ConnectedPorts.First() as CSPort).GetMemberAccessExpressionSyntax()));
// }
// else
// {
// argumentList = argumentList.AddArguments(SyntaxFactory.Argument(port.GetValueLiteralExpression()));
// }
// }
//}
InvocationExpressionSyntax invocation = null;
if (argumentList.Arguments.Any())
{
invocation = SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(this.Name), SyntaxFactory.IdentifierName(Symbol.Name))).WithArgumentList(argumentList);
}
else
{
invocation = SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName(this.Name));
}
var syntaxNode = SyntaxFactory.ExpressionStatement(invocation);
if (!string.IsNullOrWhiteSpace(this.Comment))
{
syntaxNode = syntaxNode.WithLeadingTrivia(SyntaxFactory.Comment($"// {this.Comment}"));
}
list.Add(syntaxNode);
return(list);
}
public override ExpressionSyntax AccessSyntax(CSPort sourcePort)
{
if (!sourcePort.HasProperty(GET))
{
return(null);
}
var val1Port = Ports.FirstOrDefault(x => x.HasProperty(VALUE_1)) as CSPort;
var val2Port = Ports.FirstOrDefault(x => x.HasProperty(VALUE_2)) as CSPort;
var pAccess1 = val1Port.GetFirstConnectedPortMemberAccessExpressionSyntax();
var pAccess2 = val2Port.GetFirstConnectedPortMemberAccessExpressionSyntax();
if (pAccess1 == null || pAccess2 == null)
{
return(null);
}
return(SyntaxFactory.AssignmentExpression(SyntaxKind.CoalesceAssignmentExpression, val1Port.GetFirstConnectedPortMemberAccessExpressionSyntax(), val2Port.GetFirstConnectedPortMemberAccessExpressionSyntax()));
}
public override IEnumerable <StatementSyntax> GetStatementSyntax(CSPort sourcePort)
{
var result = new List <StatementSyntax>();
var variablePort = Ports.FirstOrDefault(x => x.HasProperty(VARIABLE)) as CSPort;
var valuePort = Ports.FirstOrDefault(x => x.HasProperty(VALUE)) as CSPort;
if (variablePort.ConnectedPorts.Any())
{
if (valuePort.ConnectedPorts.Any())
{
result.Add(SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, variablePort.GetFirstConnectedPortMemberAccessExpressionSyntax(), valuePort.GetFirstConnectedPortMemberAccessExpressionSyntax())));
}
else
{
result.Add(SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, variablePort.GetFirstConnectedPortMemberAccessExpressionSyntax(), SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression))));
}
}
return(result);
}
public override IEnumerable <StatementSyntax> GetStatementSyntax(CSPort sourcePort)
{
var list = new List <StatementSyntax>();
var argumentList = SyntaxFactory.ArgumentList();
foreach (var par in (Symbol as IMethodSymbol).Parameters)
{
if (this.Ports.FirstOrDefault(x => x.Text == par.Name) is CSPort port)
{
if (port.ConnectedPorts.Any())
{
argumentList = argumentList.AddArguments(SyntaxFactory.Argument((port.ConnectedPorts.First() as CSPort).AccessSyntax()));
}
else
{
//TODO: get values properly, instead of passing everything as strings
argumentList = argumentList.AddArguments(SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression, SyntaxFactory.Literal(port.Value?.ToString()))));
}
}
}
var invocation = SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName(Symbol.ContainingType.ToString()), SyntaxFactory.IdentifierName(Symbol.Name))).WithArgumentList(argumentList);
var syntaxNode = SyntaxFactory.ExpressionStatement(invocation);
if (!string.IsNullOrWhiteSpace(this.Comment))
{
syntaxNode = syntaxNode.WithLeadingTrivia(SyntaxFactory.Comment($"// {this.Comment}"));
}
list.Add(syntaxNode);
return(list);
}
private string GetDataType(CSPort port)
{
return(port.Symbol?.Name.ToLower());
}
//public static Color VAR = Colors.Brown;
public static GraphColor GetPortColor(CSPort port)
{
var type = port.SymbolName?.ToLower();
switch (type)
{
case "byte":
case "byte[]":
return(GraphColor.Olive);
case "sbyte":
case "sbyte[]":
return(GraphColor.YellowGreen);
case "short":
case "short[]":
return(GraphColor.Brown);
case "ushort":
case "ushort[]":
return(GraphColor.Chocolate);
case "int":
case "int[]":
return(GraphColor.Blue);
case "uint":
case "uint[]":
return(GraphColor.Maroon);
case "long":
case "long[]":
return(GraphColor.Violet);
case "ulong":
case "ulong[]":
return(GraphColor.Chartreuse);
case "float":
case "float[]":
return(GraphColor.Purple);
case "double":
case "double[]":
return(GraphColor.BlueViolet);
case "decimal":
case "decimal[]":
return(GraphColor.Aqua);
case "char":
case "char[]":
return(GraphColor.OrangeRed);
case "string":
case "string[]":
return(GraphColor.Orange);
case "bool":
case "bool[]":
return(GraphColor.Lime);
case "color":
case "color[]":
return(GraphColor.Magenta);
//case "image":
//case "image[]":
// return GraphColor.Maroon;
//case "icon":
// return GraphColor.Maroon;
case "enum":
case "enum[]":
return(GraphColor.Aquamarine);
case "size":
case "size[]":
return(GraphColor.BurlyWood);
case "point":
case "point[]":
return(GraphColor.IndianRed);
case "font":
case "font[]":
return(GraphColor.Cyan);
case "datetime":
case "datetime[]":
return(GraphColor.MediumVioletRed);
case "object":
case "object[]":
return(GraphColor.Red);
//case "form":
// return GraphColor.Yellow;
default:
return(RandomColor(port.Symbol));
}
}
public override ExpressionSyntax AccessSyntax(CSPort sourcePort)
{
return(SyntaxFactory.ObjectCreationExpression(SyntaxFactory.ParseTypeName(SymbolName)).WithArgumentList(SyntaxFactory.ArgumentList()));
}
//#error create instance should specify costructors as a sub menu
public override IEnumerable <StatementSyntax> GetStatementSyntax(CSPort sourcePort)
{
return(new[] { SyntaxFactory.ExpressionStatement(SyntaxFactory.ObjectCreationExpression(SyntaxFactory.ParseTypeName(SymbolName)).WithArgumentList(SyntaxFactory.ArgumentList())) });
}
public virtual ExpressionSyntax AccessSyntax(CSPort sourcePort)
{
return(null);
}
public virtual IEnumerable <StatementSyntax> GetStatementSyntax(CSPort sourcePort)
{
return(null);
}
public override ExpressionSyntax AccessSyntax(CSPort sourcePort)
{
return(SyntaxFactory.IdentifierName(this.Name));
}
