org.yakindu.sct.model.stext.expressions.STextExpressionParser.java Source code

Introduction

Here is the source code for org.yakindu.sct.model.stext.expressions.STextExpressionParser.java

Source

/**
 * Copyright (c) 2015 committers of YAKINDU and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     committers of YAKINDU - initial API and implementation
 */
package org.yakindu.sct.model.stext.expressions;

import java.io.StringReader;

import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource.Diagnostic;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.xtext.ParserRule;
import org.eclipse.xtext.XtextFactory;
import org.eclipse.xtext.diagnostics.Severity;
import org.eclipse.xtext.linking.ILinker;
import org.eclipse.xtext.nodemodel.INode;
import org.eclipse.xtext.parser.IParseResult;
import org.eclipse.xtext.parser.IParser;
import org.eclipse.xtext.resource.impl.ListBasedDiagnosticConsumer;
import org.eclipse.xtext.util.CancelIndicator;
import org.yakindu.sct.domain.extension.DomainRegistry;
import org.yakindu.sct.model.sgraph.SGraphFactory;
import org.yakindu.sct.model.sgraph.SGraphPackage;
import org.yakindu.sct.model.sgraph.Scope;
import org.yakindu.sct.model.sgraph.SpecificationElement;
import org.yakindu.sct.model.sgraph.Statechart;
import org.yakindu.sct.model.sgraph.util.ContextElementAdapter;
import org.yakindu.sct.model.stext.resource.StextResource;
import org.yakindu.sct.model.stext.stext.InterfaceScope;
import org.yakindu.sct.model.stext.stext.InternalScope;

import com.google.common.collect.Multimap;
import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.name.Named;

public class STextExpressionParser implements IExpressionParser {

    public static class LinkingException extends RuntimeException {
        private static final long serialVersionUID = 1L;

        public LinkingException(String msg) {
            super(msg);
        }
    }

    public static class SyntaxException extends RuntimeException {
        private static final long serialVersionUID = 1L;

        public SyntaxException(String msg) {
            super(msg);
        }
    }

    @Inject
    private IParser parser;
    @Inject
    private ILinker linker;
    @Inject
    private Injector injector;

    @Inject
    @Named(DomainRegistry.DOMAIN_ID)
    private String domainId;

    public StextResource getResource() {
        final StextResource resource = new StextResource();
        injector.injectMembers(resource);
        resource.eAdapters().add(new ContextElementAdapter(new ContextElementAdapter.IContextElementProvider() {
            public EObject getContextObject() {
                return (EObject) EcoreUtil.getObjectByType(resource.getContents(),
                        SGraphPackage.Literals.STATECHART);
            }
        }));
        ResourceSet set = new ResourceSetImpl();
        set.getResources().add(resource);
        return resource;
    }

    public EObject parseExpression(String expression, String ruleName) {
        return parseExpression(expression, ruleName, (String) null);
    }

    public EObject parseExpression(String expression, String ruleName, String specification) {
        StextResource resource = getResource();
        resource.setURI(URI.createURI("path", true));
        ParserRule parserRule = XtextFactory.eINSTANCE.createParserRule();
        parserRule.setName(ruleName);
        IParseResult result = parser.parse(parserRule, new StringReader(expression));
        EObject rootASTElement = result.getRootASTElement();
        resource.getContents().add(rootASTElement);
        ListBasedDiagnosticConsumer diagnosticsConsumer = new ListBasedDiagnosticConsumer();
        Statechart sc = SGraphFactory.eINSTANCE.createStatechart();
        sc.setDomainID(domainId);
        sc.setName("sc");
        if (specification != null) {
            sc.setSpecification(specification);
        }
        resource.getContents().add(sc);
        linker.linkModel(sc, diagnosticsConsumer);
        linker.linkModel(rootASTElement, diagnosticsConsumer);
        resource.resolveLazyCrossReferences(CancelIndicator.NullImpl);
        resource.resolveLazyCrossReferences(CancelIndicator.NullImpl);
        Multimap<SpecificationElement, Diagnostic> diagnostics = resource.getLinkingDiagnostics();
        if (diagnostics.size() > 0) {
            throw new LinkingException(diagnostics.toString());
        }
        if (result.hasSyntaxErrors()) {
            StringBuilder errorMessages = new StringBuilder();
            Iterable<INode> syntaxErrors = result.getSyntaxErrors();
            for (INode iNode : syntaxErrors) {
                errorMessages.append(iNode.getSyntaxErrorMessage());
                errorMessages.append("\n");
            }
            throw new SyntaxException("Could not parse expression, syntax errors: " + errorMessages);
        }
        if (diagnosticsConsumer.hasConsumedDiagnostics(Severity.ERROR)) {
            throw new LinkingException("Error during linking: " + diagnosticsConsumer.getResult(Severity.ERROR));
        }
        return rootASTElement;
    }

    public Scope createInternalScope(String contextScope) {
        ParserRule parserRule = XtextFactory.eINSTANCE.createParserRule();
        parserRule.setName(InternalScope.class.getSimpleName());
        IParseResult result = parser.parse(parserRule, new StringReader(contextScope));
        return (Scope) result.getRootASTElement();
    }

    public Scope createInterfaceScope(String contextScope) {
        ParserRule parserRule = XtextFactory.eINSTANCE.createParserRule();
        parserRule.setName(InterfaceScope.class.getSimpleName());
        IParseResult result = parser.parse(parserRule, new StringReader(contextScope));
        return (Scope) result.getRootASTElement();
    }

}