org.eclipse.osbp.xtext.strategy/xtend-gen/org/eclipse/osbp/xtext/strategy/jvmmodel/StrategyDSLFocusingEnhancerCreator.java

/**
 * Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
 * 
 *  All rights reserved. This program and the accompanying materials
 *  are made available under the terms of the Eclipse Public License 2.0 
 *  which accompanies this distribution, and is available at
 *  https://www.eclipse.org/legal/epl-2.0/
 *
 *  SPDX-License-Identifier: EPL-2.0
 * 
 *  Contributors:
 * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
 * 
 * 
 *  This copyright notice shows up in the generated Java code
 */
package org.eclipse.osbp.xtext.strategy.jvmmodel;

import javax.inject.Inject;
import org.eclipse.emf.common.util.EList;
import org.eclipse.osbp.ecview.extension.api.IFocusingEnhancer;
import org.eclipse.osbp.ecview.extension.model.YStrategyLayout;
import org.eclipse.osbp.utils.annotation.CommonUtils;
import org.eclipse.osbp.xtext.strategy.FocusingEnhancer;
import org.eclipse.osbp.xtext.strategy.FocusingStrategy;
import org.eclipse.osbp.xtext.strategy.StrategyPackage;
import org.eclipse.osbp.xtext.strategy.constants.StrategyConstants;
import org.eclipse.xtend2.lib.StringConcatenation;
import org.eclipse.xtext.common.types.JvmAnnotationReference;
import org.eclipse.xtext.common.types.JvmFormalParameter;
import org.eclipse.xtext.common.types.JvmGenericType;
import org.eclipse.xtext.common.types.JvmMember;
import org.eclipse.xtext.common.types.JvmOperation;
import org.eclipse.xtext.common.types.JvmVisibility;
import org.eclipse.xtext.xbase.compiler.output.ITreeAppendable;
import org.eclipse.xtext.xbase.jvmmodel.IJvmDeclaredTypeAcceptor;
import org.eclipse.xtext.xbase.jvmmodel.JvmAnnotationReferenceBuilder;
import org.eclipse.xtext.xbase.jvmmodel.JvmTypeReferenceBuilder;
import org.eclipse.xtext.xbase.jvmmodel.JvmTypesBuilder;
import org.eclipse.xtext.xbase.lib.Extension;
import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
import org.osgi.service.component.annotations.Component;

@SuppressWarnings("all")
public class StrategyDSLFocusingEnhancerCreator {
  @Inject
  @Extension
  private JvmTypesBuilder _jvmTypesBuilder;
  
  @Inject
  @Extension
  private StrategyConstants _strategyConstants;
  
  @Inject
  @Extension
  private CommonUtils _commonUtils;
  
  private JvmAnnotationReferenceBuilder _annotationTypesBuilder;
  
  private JvmTypeReferenceBuilder _typeReferenceBuilder;
  
  public void createFocusingEnhancer(final StrategyPackage pckg, final FocusingEnhancer focusingEnhancer, final IJvmDeclaredTypeAcceptor acceptor, final JvmAnnotationReferenceBuilder annotationTypesBuilder, final JvmTypeReferenceBuilder typeReferenceBuilder) {
    this.createFocusingEnhancer(pckg, focusingEnhancer, acceptor, annotationTypesBuilder, typeReferenceBuilder, false);
  }
  
  public void createFocusingEnhancer(final StrategyPackage pckg, final FocusingEnhancer focusingEnhancer, final IJvmDeclaredTypeAcceptor acceptor, final JvmAnnotationReferenceBuilder annotationTypesBuilder, final JvmTypeReferenceBuilder typeReferenceBuilder, final boolean osdefault) {
    this._annotationTypesBuilder = annotationTypesBuilder;
    this._typeReferenceBuilder = typeReferenceBuilder;
    StringConcatenation _builder = new StringConcatenation();
    String _name = pckg.getName();
    _builder.append(_name);
    _builder.append(".");
    String _strategyClassName = this.getStrategyClassName(focusingEnhancer, osdefault);
    _builder.append(_strategyClassName);
    JvmGenericType clsStrategy = this._jvmTypesBuilder.toClass(focusingEnhancer, _builder.toString());
    clsStrategy.getSuperTypes().add(this._typeReferenceBuilder.typeRef(IFocusingEnhancer.class));
    final Procedure1<JvmGenericType> _function = (JvmGenericType it) -> {
      JvmAnnotationReference annotationRef = this._annotationTypesBuilder.annotationRef(Component.class);
      StringConcatenation _builder_1 = new StringConcatenation();
      _builder_1.append("ecview.focusing.enhancer.id=");
      String _strategyClassName_1 = this.getStrategyClassName(focusingEnhancer, osdefault);
      _builder_1.append(_strategyClassName_1);
      final String propContent = _builder_1.toString();
      if (osdefault) {
        String[] propContents = new String[2];
        propContents[0] = propContent;
        propContents[1] = "ecview.focusing.enhancer.default=true";
        this._commonUtils.addAnnAttrArr(annotationRef, focusingEnhancer, "property", propContents);
      } else {
        this._commonUtils.addAnnAttr(annotationRef, focusingEnhancer, "property", propContent);
      }
      EList<JvmAnnotationReference> _annotations = it.getAnnotations();
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, annotationRef);
      this.toOperations(it, focusingEnhancer);
    };
    acceptor.<JvmGenericType>accept(clsStrategy, _function);
  }
  
  public void toOperations(final JvmGenericType type, final FocusingEnhancer focusingEnhancer) {
    EList<JvmMember> _members = type.getMembers();
    final Procedure1<JvmOperation> _function = (JvmOperation it) -> {
      EList<JvmAnnotationReference> _annotations = it.getAnnotations();
      JvmAnnotationReference _annotationRef = this._annotationTypesBuilder.annotationRef(Override.class);
      this._jvmTypesBuilder.<JvmAnnotationReference>operator_add(_annotations, _annotationRef);
      it.setVisibility(JvmVisibility.PUBLIC);
      EList<JvmFormalParameter> _parameters = it.getParameters();
      JvmFormalParameter _parameter = this._jvmTypesBuilder.toParameter(focusingEnhancer, "yLayout", this._typeReferenceBuilder.typeRef(YStrategyLayout.class));
      this._jvmTypesBuilder.<JvmFormalParameter>operator_add(_parameters, _parameter);
      final Procedure1<ITreeAppendable> _function_1 = (ITreeAppendable it_1) -> {
        it_1.append(this.getEnhanceFocusingBody(focusingEnhancer));
      };
      this._jvmTypesBuilder.setBody(it, _function_1);
    };
    JvmOperation _method = this._jvmTypesBuilder.toMethod(focusingEnhancer, "enhanceFocusing", this._typeReferenceBuilder.typeRef(Void.TYPE), _function);
    this._jvmTypesBuilder.<JvmOperation>operator_add(_members, _method);
  }
  
  public String getEnhanceFocusingBody(final FocusingEnhancer focusingEnhancer) {
    StringConcatenation _builder = new StringConcatenation();
    _builder.append("yLayout.getFocusingStrategies().clear();");
    String body = _builder.toString();
    int idx = 1;
    EList<FocusingStrategy> _focusingStrategies = focusingEnhancer.getFocusingStrategies();
    for (final FocusingStrategy focusingStrategy : _focusingStrategies) {
      {
        StringConcatenation _builder_1 = new StringConcatenation();
        _builder_1.append(body);
        _builder_1.newLineIfNotEmpty();
        _builder_1.append("YDelegatingFocusingStrategy yStgy");
        _builder_1.append(idx);
        _builder_1.append(" = YECviewFactory.eINSTANCE.createYDelegatingFocusingStrategy();");
        _builder_1.newLineIfNotEmpty();
        _builder_1.append("yStgy");
        _builder_1.append(idx);
        _builder_1.append(".setDelegateStrategyId(\"");
        String _ecviewFocusingId = focusingStrategy.getEcviewFocusingId();
        _builder_1.append(_ecviewFocusingId);
        _builder_1.append("\");");
        _builder_1.newLineIfNotEmpty();
        _builder_1.append("yLayout.getFocusingStrategies().add(yStgy");
        _builder_1.append(idx);
        _builder_1.append(");");
        body = _builder_1.toString();
        idx++;
      }
    }
    return body;
  }
  
  public String getStrategyClassName(final FocusingEnhancer focusingEnhancer, final boolean osdefault) {
    CharSequence focusingEnhancerClassName = this.getNotDefaultStrategyClassName(focusingEnhancer);
    if (osdefault) {
      focusingEnhancerClassName = this.getDefaultStrategyClassName();
    }
    StringConcatenation _builder = new StringConcatenation();
    _builder.append(focusingEnhancerClassName);
    return _builder.toString();
  }
  
  public CharSequence getNotDefaultStrategyClassName(final FocusingEnhancer focusingEnhancer) {
    StringConcatenation _builder = new StringConcatenation();
    String _name = focusingEnhancer.getName();
    _builder.append(_name);
    _builder.append(this._strategyConstants.FOCUSING_ENHANCER_PREFIX);
    return _builder;
  }
  
  public CharSequence getDefaultStrategyClassName() {
    StringConcatenation _builder = new StringConcatenation();
    _builder.append("Default");
    _builder.append(this._strategyConstants.FOCUSING_ENHANCER_PREFIX);
    return _builder;
  }
}