Example #1
0
        public static IEnumerable <PropertyDeclarationSyntax> Build(
            IEnumerable <MethodDescription> methodsDescription,
            string classRefName,
            string lockObjectName)
        {
            yield return(BuildProperty(classRefName, GenerateFindClassExpression(), lockObjectName));

            foreach (var description in methodsDescription)
            {
                var isStatic       = description.ModifiersDescriptions.Contains(ModifierDescription.STATIC);
                var methodCallable = SyntaxFactory.IdentifierName(
                    $"Get{(isStatic ? "Static" : "")}Method");

                var args = new List <ExpressionSyntax>
                {
                    SyntaxFactory.LiteralExpression(
                        SyntaxKind.StringLiteralExpression,
                        SyntaxFactory.Literal(description.IsConstructor ? "<init>" : description.Name)),

                    SyntaxFactory.LiteralExpression(
                        SyntaxKind.StringLiteralExpression,
                        SyntaxFactory.Literal(
                            ServiceUtils.GetMethodJavaSignature(description)))
                };

                yield return(BuildProperty(
                                 ServiceUtils.GetMethodRefName(description),
                                 RoslynUtils.CallExpression(methodCallable, args),
                                 lockObjectName));
            }
        }
Example #2
0
 private static StatementSyntax JvmReturnStatement()
 {
     return(RoslynUtils.CallExpression(
                SyntaxFactory.IdentifierName("JvmManager")
                .MemberAccessExpression("INSTANCE")
                .MemberAccessExpression("GetEnv")
                ).ToStatement());
 }
Example #3
0
        private static ExpressionSyntax GenerateFindClassExpression()
        {
            var getEnvCallExpr = RoslynUtils.CallExpression(
                SyntaxFactory.IdentifierName("JvmManager")
                .MemberAccessExpression("INSTANCE")
                .MemberAccessExpression("GetEnv"));

            return(RoslynUtils.CallExpression(
                       getEnvCallExpr.MemberAccessExpression("FindClass")));
        }
Example #4
0
        private ExpressionSyntax GetExpressionFor(ParameterDescription parameter)
        {
            var jvmEnvExpr = SyntaxFactory.IdentifierName("Env");

            var jObjectsGettingExpressions = new Dictionary <string, ExpressionSyntax>
            {
                { "string", RoslynUtils.CallExpression(
                      jvmEnvExpr.MemberAccessExpression("NewStringUtf"), new List <ExpressionSyntax>
                    {
                        SyntaxFactory.IdentifierName(parameter.Name)
                    }) }
            };

            return(jObjectsGettingExpressions[parameter.Type]);
        }
Example #5
0
        private ExpressionSyntax CallJvmExpression(string method, string callableObject,
                                                   string methodRefName, IEnumerable <ParameterDescription> arguments)
        {
            var newObjExpr = SyntaxFactory
                             .IdentifierName("Env")
                             .MemberAccessExpression(method);

            var args = new List <ExpressionSyntax>
            {
                SyntaxFactory.IdentifierName(callableObject).MemberAccessExpression("Ptr"),
                SyntaxFactory
                .IdentifierName(methodRefName)
                .MemberAccessExpression("Ptr"),
            };

            args.AddRange(arguments.Select(GenerateJValueExpressionFor));
            return(RoslynUtils.CallExpression(newObjExpr, args));
        }