ErlangOutlineTreeProviderBase.java

package org.erlide.ui.outline;

import com.google.common.base.Objects;
import com.google.inject.Inject;
import java.util.Arrays;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.xtext.resource.IResourceDescriptions;
import org.eclipse.xtext.resource.impl.ResourceDescriptionsProvider;
import org.eclipse.xtext.ui.editor.outline.IOutlineNode;
import org.eclipse.xtext.ui.editor.outline.impl.AbstractOutlineNode;
import org.eclipse.xtext.ui.editor.outline.impl.DefaultOutlineTreeProvider;
import org.eclipse.xtext.ui.editor.outline.impl.DocumentRootNode;
import org.eclipse.xtext.ui.editor.outline.impl.EStructuralFeatureNode;
import org.eclipse.xtext.xbase.lib.Extension;
import org.erlide.erlang.DefineAttribute;
import org.erlide.erlang.ErlangPackage;
import org.erlide.erlang.ExportAttribute;
import org.erlide.erlang.Form;
import org.erlide.erlang.FunRef;
import org.erlide.erlang.FunctionClause;
import org.erlide.erlang.Module;
import org.erlide.erlang.ModuleAttribute;
import org.erlide.erlang.RecordAttribute;
import org.erlide.erlang.ScopeExtensions;
import org.erlide.ui.outline.ErlangOutlineNode;

/**
 * outline structure -- group same type of forms under common parent
 */
@SuppressWarnings("all")
public class ErlangOutlineTreeProviderBase extends DefaultOutlineTreeProvider {
  @Inject
  @Extension
  private ScopeExtensions _scopeExtensions;
  
  protected boolean _isLeaf(final FunctionClause c) {
    return true;
  }
  
  protected boolean _isLeaf(final FunRef c) {
    return true;
  }
  
  @Inject
  private ResourceDescriptionsProvider provider;
  
  public void debug_test(final Module module) {
    final Resource resource = module.eResource();
    IResourceDescriptions descriptions = this.provider.getResourceDescriptions(resource);
    ResourceSet resourceSet = resource.getResourceSet();
  }
  
  protected void _createChildren(final DocumentRootNode parent, final Module module) {
    final ErlangOutlineNode recordsNode = new ErlangOutlineNode(parent, null, "Records:", false);
    final ErlangOutlineNode exportsNode = new ErlangOutlineNode(parent, null, "Exports:", false);
    final ErlangOutlineNode macrosNode = new ErlangOutlineNode(parent, null, "Macros:", false);
    EList<Form> _forms = module.getForms();
    for (final Form element : _forms) {
      {
        AbstractOutlineNode _switchResult = null;
        boolean _matched = false;
        if (!_matched) {
          if (element instanceof ModuleAttribute) {
            _matched=true;
            _switchResult = null;
          }
        }
        if (!_matched) {
          if (element instanceof RecordAttribute) {
            _matched=true;
            _switchResult = recordsNode;
          }
        }
        if (!_matched) {
          if (element instanceof ExportAttribute) {
            _matched=true;
            _switchResult = exportsNode;
          }
        }
        if (!_matched) {
          if (element instanceof DefineAttribute) {
            _matched=true;
            _switchResult = macrosNode;
          }
        }
        if (!_matched) {
          _switchResult = parent;
        }
        final AbstractOutlineNode theParent = _switchResult;
        boolean _notEquals = (!Objects.equal(theParent, null));
        if (_notEquals) {
          this.createChildren(theParent, element);
        }
      }
    }
  }
  
  protected void _createChildren(final ErlangOutlineNode parent, final ExportAttribute attr) {
    EList<EObject> _eContents = attr.eContents();
    for (final EObject element : _eContents) {
      this.createNode(parent, element);
    }
  }
  
  protected void _createChildren(final ErlangOutlineNode parent, final DefineAttribute attr) {
    String _macroName = attr.getMacroName();
    final EStructuralFeatureNode name = this.createEStructuralFeatureNode(parent, attr, ErlangPackage.Literals.DEFINE_ATTRIBUTE__MACRO_NAME, null, _macroName, true);
    EList<EObject> _eContents = attr.eContents();
    for (final EObject element : _eContents) {
      this.createNode(name, element);
    }
  }
  
  protected void _createChildren(final ErlangOutlineNode parent, final RecordAttribute attr) {
    String _name = attr.getName();
    final EStructuralFeatureNode name = this.createEStructuralFeatureNode(parent, attr, ErlangPackage.Literals.RECORD_ATTRIBUTE__NAME, null, _name, true);
    EList<EObject> _eContents = attr.eContents();
    for (final EObject element : _eContents) {
      this.createNode(name, element);
    }
  }
  
  public boolean isLeaf(final Object c) {
    if (c instanceof FunRef) {
      return _isLeaf((FunRef)c);
    } else if (c instanceof FunctionClause) {
      return _isLeaf((FunctionClause)c);
    } else if (c instanceof EObject) {
      return _isLeaf((EObject)c);
    } else if (c != null) {
      return _isLeaf(c);
    } else {
      throw new IllegalArgumentException("Unhandled parameter types: " +
        Arrays.<Object>asList(c).toString());
    }
  }
  
  public void createChildren(final IOutlineNode parent, final EObject module) {
    if (parent instanceof ErlangOutlineNode
         && module instanceof DefineAttribute) {
      _createChildren((ErlangOutlineNode)parent, (DefineAttribute)module);
      return;
    } else if (parent instanceof ErlangOutlineNode
         && module instanceof ExportAttribute) {
      _createChildren((ErlangOutlineNode)parent, (ExportAttribute)module);
      return;
    } else if (parent instanceof ErlangOutlineNode
         && module instanceof RecordAttribute) {
      _createChildren((ErlangOutlineNode)parent, (RecordAttribute)module);
      return;
    } else if (parent instanceof DocumentRootNode
         && module instanceof Module) {
      _createChildren((DocumentRootNode)parent, (Module)module);
      return;
    } else if (parent instanceof DocumentRootNode
         && module != null) {
      _createChildren((DocumentRootNode)parent, module);
      return;
    } else if (parent instanceof EStructuralFeatureNode
         && module != null) {
      _createChildren((EStructuralFeatureNode)parent, module);
      return;
    } else if (parent != null
         && module != null) {
      _createChildren(parent, module);
      return;
    } else if (parent != null
         && module != null) {
      _createChildren(parent, module);
      return;
    } else {
      throw new IllegalArgumentException("Unhandled parameter types: " +
        Arrays.<Object>asList(parent, module).toString());
    }
  }
}