org.eclipse.osbp.xtext.datamartdsl/xtend-gen/org/eclipse/osbp/xtext/datamartdsl/util/EventBrokerDatamartUtils.java

/**
 * Copyright (c) 2013, 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 v1.0
 *  which accompanies this distribution, and is available at
 *  http://www.eclipse.org/legal/epl-v10.html
 * 
 *  Contributors:
 * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
 */
package org.eclipse.osbp.xtext.datamartdsl.util;

import com.google.common.base.Objects;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import javax.inject.Inject;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.osbp.xtext.datamartdsl.DatamartDefinition;
import org.eclipse.osbp.xtext.datamartdsl.EventBrokerDataMart;
import org.eclipse.osbp.xtext.datamartdsl.jvmmodel.DatamartDSLJvmModelInferrer;
import org.eclipse.xtend2.lib.StringConcatenation;
import org.eclipse.xtext.xbase.lib.CollectionLiterals;
import org.eclipse.xtext.xbase.lib.Extension;

@SuppressWarnings("all")
public class EventBrokerDatamartUtils {
  @Inject
  @Extension
  private DatamartDSLJvmModelInferrer datamartInferrer;
  
  public HashMap<String, String> getUsedFilterInDatamart(final EventBrokerDataMart datamart, final HashMap<String, String> filterIdMap) {
    HashMap<String, String> usedFilterIdMap = CollectionLiterals.<String, String>newHashMap();
    Set<Map.Entry<String, String>> _entrySet = filterIdMap.entrySet();
    for (final Map.Entry<String, String> filter : _entrySet) {
      String _filter = datamart.getFilter();
      String _value = filter.getValue();
      boolean _equals = _filter.equals(_value);
      if (_equals) {
        String _key = filter.getKey();
        String _value_1 = filter.getValue();
        usedFilterIdMap.put(_key, _value_1);
      }
    }
    return usedFilterIdMap;
  }
  
  public HashMap<String, String> getFilterMap(final EventBrokerDataMart datamart) {
    HashMap<String, String> filterIdMap = new HashMap<String, String>();
    DatamartDefinition _datamartDef = datamart.getDatamartDef();
    this.datamartInferrer.createFilterMap(_datamartDef, filterIdMap);
    return filterIdMap;
  }
  
  public void removeAlreadyUsedFilter(final EList<EventBrokerDataMart> datamarts, final HashMap<String, HashMap<String, String>> datamartsFilterMap) {
    for (final EventBrokerDataMart dat : datamarts) {
      String _filter = dat.getFilter();
      boolean _notEquals = (!Objects.equal(_filter, null));
      if (_notEquals) {
        DatamartDefinition _datamartDef = dat.getDatamartDef();
        String _name = _datamartDef.getName();
        HashMap<String, String> _get = datamartsFilterMap.get(_name);
        HashMap<String, String> filterIdMap = ((HashMap<String, String>) _get);
        boolean _notEquals_1 = (!Objects.equal(filterIdMap, null));
        if (_notEquals_1) {
          Object _clone = filterIdMap.clone();
          HashMap<String, String> filterIdMapTemp = ((HashMap<String, String>) _clone);
          Set<Map.Entry<String, String>> _entrySet = filterIdMapTemp.entrySet();
          for (final Map.Entry<String, String> filter : _entrySet) {
            String _filter_1 = dat.getFilter();
            String _value = filter.getValue();
            boolean _equals = _filter_1.equals(_value);
            if (_equals) {
              String _key = filter.getKey();
              filterIdMap.remove(_key);
            }
          }
        }
      }
    }
  }
  
  public HashMap<String, String> getFilterMap(final EList<EventBrokerDataMart> datamarts) {
    HashMap<String, String> filterMap = CollectionLiterals.<String, String>newHashMap();
    return this.getFilterMap(datamarts, filterMap);
  }
  
  public HashMap<String, String> getFilterMap(final EList<EventBrokerDataMart> datamarts, final HashMap<String, String> filterMap) {
    boolean _notEquals = (!Objects.equal(filterMap, null));
    if (_notEquals) {
      for (final EventBrokerDataMart datamart : datamarts) {
        HashMap<String, String> _filterMap = this.getFilterMap(datamart);
        HashMap<String, String> _usedFilterInDatamart = this.getUsedFilterInDatamart(datamart, _filterMap);
        filterMap.putAll(_usedFilterInDatamart);
      }
    }
    return filterMap;
  }
  
  public HashMap<String, HashMap<String, String>> getUsedFilterMap(final EList<EventBrokerDataMart> datamarts) {
    HashMap<String, HashMap<String, String>> usedFilterMap = CollectionLiterals.<String, HashMap<String, String>>newHashMap();
    for (final EventBrokerDataMart dat : datamarts) {
      boolean _and = false;
      boolean _notEquals = (!Objects.equal(dat, null));
      if (!_notEquals) {
        _and = false;
      } else {
        DatamartDefinition _datamartDef = dat.getDatamartDef();
        boolean _notEquals_1 = (!Objects.equal(_datamartDef, null));
        _and = _notEquals_1;
      }
      if (_and) {
        DatamartDefinition _datamartDef_1 = dat.getDatamartDef();
        String _name = _datamartDef_1.getName();
        HashMap<String, String> _filterMap = this.getFilterMap(dat);
        usedFilterMap.put(_name, _filterMap);
      }
    }
    return usedFilterMap;
  }
  
  public void fillResultWithFilter(final EList<EventBrokerDataMart> datamarts, final HashMap<String, HashMap<String, String>> usedDatamartsFilterMap, final ArrayList<EObject> result) {
    for (final EventBrokerDataMart dat : datamarts) {
      boolean _and = false;
      boolean _and_1 = false;
      boolean _and_2 = false;
      boolean _notEquals = (!Objects.equal(dat, null));
      if (!_notEquals) {
        _and_2 = false;
      } else {
        DatamartDefinition _datamartDef = dat.getDatamartDef();
        boolean _notEquals_1 = (!Objects.equal(_datamartDef, null));
        _and_2 = _notEquals_1;
      }
      if (!_and_2) {
        _and_1 = false;
      } else {
        DatamartDefinition _datamartDef_1 = dat.getDatamartDef();
        String _name = _datamartDef_1.getName();
        boolean _containsKey = usedDatamartsFilterMap.containsKey(_name);
        _and_1 = _containsKey;
      }
      if (!_and_1) {
        _and = false;
      } else {
        DatamartDefinition _datamartDef_2 = dat.getDatamartDef();
        String _name_1 = _datamartDef_2.getName();
        HashMap<String, String> _get = usedDatamartsFilterMap.get(_name_1);
        boolean _isEmpty = _get.isEmpty();
        boolean _not = (!_isEmpty);
        _and = _not;
      }
      if (_and) {
        DatamartDefinition _datamartDef_3 = dat.getDatamartDef();
        result.add(_datamartDef_3);
      }
    }
  }
  
  public CharSequence getEventBrokerMsgs(final EList<EventBrokerDataMart> datamarts) {
    StringConcatenation _builder = new StringConcatenation();
    {
      for(final EventBrokerDataMart datamart : datamarts) {
        _builder.append("eventBroker.send(\"");
        String _filter = datamart.getFilter();
        _builder.append(_filter, "");
        _builder.append("/clear\", selectedItem);");
        _builder.newLineIfNotEmpty();
        _builder.append("eventBroker.send(\"");
        String _filter_1 = datamart.getFilter();
        _builder.append(_filter_1, "");
        _builder.append("\", selectedItem);");
        _builder.newLineIfNotEmpty();
      }
    }
    return _builder;
  }
}