protected List<EPackageInfo> createEPackageInfosFromGenModel(
     URI genModelURI, Resource genModelResource) {
   //		ResourceSet resourceSet = createResourceSet(genModelURI);
   //		Resource resource = resourceSet.getResource(genModelURI, true);
   List<EPackageInfo> ePackageInfos = Lists.newArrayList();
   for (TreeIterator<EObject> i = genModelResource.getAllContents(); i.hasNext(); ) {
     EObject next = i.next();
     if (next instanceof GenPackage) {
       GenPackage genPackage = (GenPackage) next;
       EPackage ePackage = genPackage.getEcorePackage();
       URI importURI;
       if (ePackage.eResource() == null) {
         importURI = URI.createURI(ePackage.getNsURI());
       } else {
         importURI = ePackage.eResource().getURI();
       }
       EPackageInfo ePackageInfo =
           new EPackageInfo(
               ePackage,
               importURI,
               genModelURI,
               genPackage.getQualifiedPackageInterfaceName(),
               genPackage.getGenModel().getModelPluginID());
       ePackageInfos.add(ePackageInfo);
     } else if (!(next instanceof GenModel)) {
       i.prune();
     }
   }
   return ePackageInfos;
 }
 public PropertiesEditionContext genPackage2Context(GenPackage genPackage) {
   PropertiesEditionContext context = ComponentsFactory.eINSTANCE.createPropertiesEditionContext();
   context.setModel(genPackage);
   context.setDocumentation(
       "Edition Context for " + genPackage.getEcorePackage().getName() + " GenPackage");
   Category components = MappingFactory.eINSTANCE.createCategory();
   components.setName(genPackage.getEcorePackage().getName());
   context.getCategories().add(components);
   for (GenClass genClass : genPackage.getGenClasses()) {
     if (!genClass.getEcoreClass().isAbstract()) {
       components.getBindings().add(genClass2Component(genClass, genPackage));
     }
   }
   return context;
 }
  @Override
  public void execute() throws BuildException {

    EPackage.Registry.INSTANCE.put(GenModelPackage.eNS_URI, GenModelPackage.eINSTANCE);
    EPackage.Registry.INSTANCE.put(EcorePackage.eNS_URI, EcorePackage.eINSTANCE);
    EPackage.Registry.INSTANCE.put(
        "http://www.eclipse.org/uml2/2.2.0/GenModel", getUML2GenPackage());
    EPackage.Registry.INSTANCE.put(
        "http://www.eclipse.org/uml2/4.0.0/Types", getUML2TypesPackage());

    Map<String, Object> extensionToFactoryMap =
        Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap();
    extensionToFactoryMap.put(
        "ecore", new org.eclipse.emf.ecore.xmi.impl.EcoreResourceFactoryImpl());
    extensionToFactoryMap.put(
        "genmodel", new org.eclipse.emf.ecore.xmi.impl.EcoreResourceFactoryImpl());

    // We ignore the deprecation warning until the method is not available
    // anymore to keep this code runnable against old versions of EMF as
    // long as possible.
    @SuppressWarnings("deprecation")
    final Map<String, URI> packageNsURIToGenModelLocationMap =
        EcorePlugin.getEPackageNsURIToGenModelLocationMap();
    URI genModelURIObject = URI.createURI(genModelURI);
    ResourceSet rs = new ResourceSetImpl();
    Resource resource = null;
    try {
      resource = rs.getResource(genModelURIObject, true);

      for (GenPackage genPackage : ((GenModel) resource.getContents().get(0)).getGenPackages()) {
        EPackage ecorePackage = genPackage.getEcorePackage();
        String nsURI = ecorePackage.getNsURI();
        EPackage.Registry.INSTANCE.put(nsURI, ecorePackage);
      }
    } catch (Exception e) {
      e.printStackTrace();
      throw new BuildException("Can't load generator model from " + genModelURIObject);
    }

    packageNsURIToGenModelLocationMap.put(namespaceURI, genModelURIObject);
  }
 public void generateVisitors(@NonNull final GenPackage genPackage) {
   EPackage ePackage = genPackage.getEcorePackage();
   boolean _isDerived = this.isDerived();
   boolean _not = (!_isDerived);
   if (_not) {
     this.generateVisitableInterface(ePackage);
   }
   this.generateVisitorInterface(ePackage);
   this.generateDecorableVisitorInterface(
       ePackage, "org.eclipse.ocl.examples.xtext.base.basecs.util.BaseCSVisitor");
   this.generateAbstractVisitor(ePackage);
   this.generateAbstractNullVisitor(ePackage);
   this.generateAbstractDelegatingVisitor(ePackage);
   this.generateAbstractExtendingVisitor(ePackage);
 }
  public void generatePackages(
      GenModel genModel, List<GenPackage> genPackages, VirtualFile basedir) {
    for (GenPackage genPackage : genPackages) {
      genPackage.prepareCache();

      genModel.setImportManager(new ImportManager("org.bimserver.models"));

      String packageClassPathImpl = MODEL_PACKAGE + genPackage.getPackageName() + ".impl.";
      packageClassPathImpl =
          packageClassPathImpl.replace(".", File.separator)
              + genPackage.getPackageClassName()
              + ".java";
      VirtualFile packageVirtualFileImpl = basedir.createFile(packageClassPathImpl);
      packageVirtualFileImpl.setStringContent(
          new PackageClass().generate(new Object[] {genPackage, false, true}));

      genModel.setImportManager(new ImportManager("org.bimserver.models"));

      String packageClassPathInterface = MODEL_PACKAGE + genPackage.getPackageName() + ".";
      packageClassPathInterface =
          packageClassPathInterface.replace(".", File.separator)
              + genPackage.getPackageInterfaceName()
              + ".java";
      VirtualFile packageVirtualFileInterface = basedir.createFile(packageClassPathInterface);
      packageVirtualFileInterface.setStringContent(
          new PackageClass().generate(new Object[] {genPackage, true, false}));

      genModel.setImportManager(new ImportManager("org.bimserver.models"));

      String factoryClassPathImpl = MODEL_PACKAGE + genPackage.getPackageName() + ".impl.";
      factoryClassPathImpl =
          factoryClassPathImpl.replace(".", File.separator)
              + genPackage.getFactoryClassName()
              + ".java";
      VirtualFile factoryVirtualFileImpl = basedir.createFile(factoryClassPathImpl);
      factoryVirtualFileImpl.setStringContent(
          new FactoryClass().generate(new Object[] {genPackage, false, true}));

      genModel.setImportManager(new ImportManager("org.bimserver.models"));

      String factoryClassPathInterface = MODEL_PACKAGE + genPackage.getPackageName() + ".";
      factoryClassPathInterface =
          factoryClassPathInterface.replace(".", File.separator)
              + genPackage.getFactoryInterfaceName()
              + ".java";
      VirtualFile factoryVirtualFileInterface = basedir.createFile(factoryClassPathInterface);
      factoryVirtualFileInterface.setStringContent(
          new FactoryClass().generate(new Object[] {genPackage, true, false}));

      genModel.setImportManager(new ImportManager("org.bimserver.models"));

      String adapterFactoryClassPath = MODEL_PACKAGE + genPackage.getPackageName() + ".util.";
      adapterFactoryClassPath =
          adapterFactoryClassPath.replace(".", File.separator)
              + genPackage.getAdapterFactoryClassName()
              + ".java";
      VirtualFile adapterFactoryVirtualFile = basedir.createFile(adapterFactoryClassPath);
      adapterFactoryVirtualFile.setStringContent(new AdapterFactoryClass().generate(genPackage));

      genModel.setImportManager(new ImportManager("org.bimserver.models"));

      String switchClassPath = MODEL_PACKAGE + genPackage.getPackageName() + ".util.";
      switchClassPath =
          switchClassPath.replace(".", File.separator) + genPackage.getSwitchClassName() + ".java";
      VirtualFile switchClassVirtualFile = basedir.createFile(switchClassPath);
      switchClassVirtualFile.setStringContent(new SwitchClass().generate(genPackage));

      genModel.setImportManager(new ImportManager("org.bimserver.models"));

      String xmlClassPath = MODEL_PACKAGE + genPackage.getPackageName() + ".util.";
      xmlClassPath =
          xmlClassPath.replace(".", File.separator)
              + genPackage.getXMLProcessorClassName()
              + ".java";
      VirtualFile xmlClassVirtualFile = basedir.createFile(xmlClassPath);
      xmlClassVirtualFile.setStringContent(new XMLProcessorClass().generate(genPackage));

      genModel.setImportManager(new ImportManager("org.bimserver.models"));

      String resourceFactoryClassPath = MODEL_PACKAGE + genPackage.getPackageName() + ".util.";
      resourceFactoryClassPath =
          resourceFactoryClassPath.replace(".", File.separator)
              + genPackage.getResourceFactoryClassName()
              + ".java";
      VirtualFile resourceFactoryClassVirtualFile = basedir.createFile(resourceFactoryClassPath);
      resourceFactoryClassVirtualFile.setStringContent(
          new ResourceFactoryClass().generate(genPackage));

      genModel.setImportManager(new ImportManager("org.bimserver.models"));

      String resourceClassPath = MODEL_PACKAGE + genPackage.getPackageName() + ".util.";
      resourceClassPath =
          resourceClassPath.replace(".", File.separator)
              + genPackage.getResourceClassName()
              + ".java";
      VirtualFile resourceClassVirtualFile = basedir.createFile(resourceClassPath);
      resourceClassVirtualFile.setStringContent(new ResourceClass().generate(genPackage));

      // String validatorClassPath = "com.logiclabs.streamdb.models." +
      // genPackage.getPackageName() + ".util.";
      // validatorClassPath = validatorClassPath.replace(".",
      // File.separator) + genPackage.getValidatorClassName() + ".java";
      // VirtualFile validatorClassVirtualFile =
      // basedir.createFile(validatorClassPath);
      // validatorClassVirtualFile.setStringContent(new
      // ValidatorClass().generate(genPackage));

      for (GenClass genClass : genPackage.getGenClasses()) {
        genModel.setImportManager(new ImportManager("org.bimserver.models"));
        String implFileName = MODEL_PACKAGE + genPackage.getPackageName() + ".impl.";
        implFileName = implFileName.replace(".", File.separator) + genClass.getName() + "Impl.java";
        VirtualFile implVirtualFile = basedir.createFile(implFileName);
        implVirtualFile.setStringContent(
            new org.eclipse.emf.codegen.ecore.templates.model.Class()
                .generate(new Object[] {genClass, false, true}));

        genModel.setImportManager(new ImportManager("org.bimserver.models"));
        String interfaceFileName = MODEL_PACKAGE + genPackage.getPackageName() + ".";
        interfaceFileName =
            interfaceFileName.replace(".", File.separator) + genClass.getName() + ".java";
        VirtualFile interfaceVirtualFile = basedir.createFile(interfaceFileName);
        interfaceVirtualFile.setStringContent(
            new org.eclipse.emf.codegen.ecore.templates.model.Class()
                .generate(new Object[] {genClass, true, false}));
      }
      for (GenEnum genEnum : genPackage.getGenEnums()) {
        genModel.setImportManager(new ImportManager("org.bimserver.models"));

        String enumFileName = MODEL_PACKAGE + genPackage.getPackageName() + ".";
        enumFileName = enumFileName.replace(".", File.separator) + genEnum.getName() + ".java";
        VirtualFile enumVirtualFile = basedir.createFile(enumFileName);
        enumVirtualFile.setStringContent(new EnumClass().generate(genEnum));
      }
    }
  }
 public List<GenPackage> createGenPackages(GenModel genModel, VirtualFile basedir)
     throws DatabaseException {
   ResourceSetImpl resourceSet = new ResourceSetImpl();
   resourceSet
       .getResourceFactoryRegistry()
       .getExtensionToFactoryMap()
       .put("ecore", new EcoreResourceFactoryImpl());
   Map<VirtualFile, Resource> resources = new HashMap<VirtualFile, Resource>();
   genModel.initialize(schema.getEPackages());
   for (GenPackage genPackage : genModel.getGenPackages()) {
     genPackage.setBasePackage("org.bimserver.models");
   }
   for (EPackage ePackage : schema.getEPackages()) {
     // GenPackage genPackage = genModel.get
     // result.add(genPackage);
     // genModel.getGenPackages().add(genPackage);
     // genPackage.initialize(ePackage);
     // for (EClassifier eClassifier : ePackage.getEClassifiers()) {
     // if (eClassifier instanceof EClass) {
     // EClass eClass = (EClass) eClassifier;
     // GenClass genClass = GenModelFactory.eINSTANCE.createGenClass();
     // genClass.initialize(eClass);
     // genPackage.getGenClasses().add(genClass);
     // for (EStructuralFeature eStructuralFeature :
     // eClass.getEStructuralFeatures()) {
     // GenFeature genFeature =
     // GenModelFactory.eINSTANCE.createGenFeature();
     // genFeature.initialize(eStructuralFeature);
     // genFeature.setEcoreFeature(eStructuralFeature);
     // genClass.getGenFeatures().add(genFeature);
     // }
     // } else if (eClassifier instanceof EEnum) {
     // EEnum eEnum = (EEnum) eClassifier;
     // GenEnum genEnum = GenModelFactory.eINSTANCE.createGenEnum();
     // genEnum.setEcoreEnum(eEnum);
     // genPackage.getGenEnums().add(genEnum);
     // for (EEnumLiteral eEnumLiteral : eEnum.getELiterals()) {
     // GenEnumLiteral genEnumLiteral =
     // GenModelFactory.eINSTANCE.createGenEnumLiteral();
     // genEnumLiteral.setEcoreEnumLiteral(eEnumLiteral);
     // genEnum.getGenEnumLiterals().add(genEnumLiteral);
     // }
     // } else if (eClassifier instanceof EDataType) {
     // GenDataType genDataType =
     // GenModelFactory.eINSTANCE.createGenDataType();
     // genDataType.setEcoreDataType((EDataType) eClassifier);
     // genPackage.getGenDataTypes().add(genDataType);
     // }
     // }
     Resource resource = resourceSet.createResource(URI.createURI(ePackage.getName() + ".ecore"));
     resource.getContents().add(ePackage);
     VirtualFile ecoreFile =
         basedir.createFile(
             MODEL_PACKAGE.replace(".", "/")
                 + ePackage.getName()
                 + "/impl/"
                 + ePackage.getName()
                 + ".ecore");
     resources.put(ecoreFile, resource);
   }
   for (VirtualFile virtualFile : resources.keySet()) {
     try {
       Resource resource = resources.get(virtualFile);
       OutputStream openOutputStream = virtualFile.openOutputStream();
       resource.save(openOutputStream, null);
       openOutputStream.close();
     } catch (IOException e) {
       e.printStackTrace();
     }
   }
   return genModel.getGenPackages();
 }
  public Object execute(ExecutionEvent event) throws ExecutionException {
    String tag = null;
    boolean copyLibraries = false;
    try {
      copyLibraries =
          (event.getParameter("emf-rest.copyLibraries") == null
              ? false
              : Boolean.valueOf(event.getParameter("emf-rest.copyLibraries")));
      tag = event.getParameter("emf-rest.tagParameter");
    } catch (Exception e) {
      e.printStackTrace();
    }
    IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindowChecked(event);
    IStructuredSelection selection =
        (IStructuredSelection) window.getSelectionService().getSelection();
    IResource ecoreResource = (IResource) selection.getFirstElement();

    if (tag != null && tag.equals("None")) {
      GenerationListener genlistener =
          new GenerationListener(ecoreResource.getProject(), Platform.getBundle("emf-rest"), true);
      genlistener.afterFinishExecution(null, null, null);
      return null;
    }

    HashMap<String, Object> variables = new HashMap<String, Object>();
    variables.put("ecore_file", ecoreResource.getLocation().toOSString());
    variables.put(
        "genModel_file",
        ecoreResource.getLocation().toOSString().replaceFirst(".ecore", ".genmodel"));
    variables.put(
        "output", ecoreResource.getProject().findMember("src").getLocation().toOSString());
    try {
      variables.put(
          "modelDirectory",
          ecoreResource.getProject().findMember("WebContent/models").getLocation().toOSString());
    } catch (Exception ex) {
      variables.put("modelDirectory", "");
    }
    File scriptDir =
        new File(ecoreResource.getProject().getLocation().toOSString() + "/WebContent/scripts");
    if (tag == null || tag.equals("javascript")) {
      scriptDir.mkdirs();
    }
    variables.put(
        "output_js", ecoreResource.getProject().getLocation().toOSString() + "/WebContent/scripts");
    HashMap<String, GenPackage> usedGenPackages = new HashMap<String, GenPackage>();

    try {
      ResourceSet eCoreResourceSet = new ResourceSetImpl();
      Resource eCoreResource =
          eCoreResourceSet.createResource(
              URI.createFileURI(ecoreResource.getLocation().toOSString()));
      eCoreResource.load(null);
      EPackage ePackage = (EPackage) eCoreResource.getContents().get(0);
      for (EAnnotation eAnnotation : ePackage.getEAnnotations()) {
        if (eAnnotation.getSource().equalsIgnoreCase("emf.gen.usedGenPackage")) {
          ResourceSet genModelResourceSet = new ResourceSetImpl();
          Resource genModelResource =
              genModelResourceSet.createResource(
                  URI.createURI(eAnnotation.getDetails().get("genModel"), false));
          genModelResource.load(null);
          GenModel genModel = (GenModel) genModelResource.getContents().get(0);
          for (GenPackage genPackage : genModel.getGenPackages()) {
            String usedGenPackageName = eAnnotation.getDetails().get("name");
            if (genPackage.getEcorePackage().getName().equals(usedGenPackageName)) {
              usedGenPackages.put(usedGenPackageName, genPackage);
            }
          }
        }
      }
    } catch (Exception ex) {
      ex.printStackTrace();
    }

    variables.put("usedGenPackages", usedGenPackages);
    variables.put("pluginName", ecoreResource.getProject().getName());
    variables.put("foreignModel", ecoreResource.getName());

    File webContentModelsPath =
        new File(
            ecoreResource.getProject().findMember("WebContent/models").getLocation().toOSString());
    String modelName = "";
    for (File file : webContentModelsPath.listFiles()) {
      if (file.getName().endsWith(".xmi")) {
        modelName = file.getName().substring(0, file.getName().lastIndexOf("."));
      }
    }
    variables.put("modelName", modelName);

    MTCChoreographer choreographer =
        MTCStandaloneUtils.startMTC(
            ecoreResource.getProject(),
            "emf-rest",
            "default.mtc",
            variables,
            (tag == null ? null : Collections.singletonList(tag)));
    ArrayList<IResource> resourceToRefresh = new ArrayList<IResource>();
    resourceToRefresh.add(ecoreResource.getProject());
    choreographer.addExecutionListener(
        new GenerationListener(
            ecoreResource.getProject(), Platform.getBundle("emf-rest"), copyLibraries));
    choreographer.start();
    choreographer.modelReady("Ecore Fully Annotated", null);
    return null;
  }
 public void buildMap(final GenModel genModel) {
   Iterable<EObject> _allContentsIterable = XcoreExtensions.allContentsIterable(genModel);
   for (final EObject genElement : _allContentsIterable) {
     boolean _matched = false;
     if (!_matched) {
       if (genElement instanceof GenPackage) {
         final GenPackage _genPackage = (GenPackage) genElement;
         _matched = true;
         EPackage _ecorePackage = _genPackage.getEcorePackage();
         ToXcoreMapping _toXcoreMapping = this.mapper.getToXcoreMapping(_ecorePackage);
         XNamedElement _xcoreElement = _toXcoreMapping.getXcoreElement();
         final XPackage xPackage = ((XPackage) _xcoreElement);
         boolean _notEquals = (!Objects.equal(xPackage, null));
         if (_notEquals) {
           XPackageMapping _mapping = this.mapper.getMapping(xPackage);
           _mapping.setGenPackage(_genPackage);
           ToXcoreMapping _toXcoreMapping_1 = this.mapper.getToXcoreMapping(_genPackage);
           _toXcoreMapping_1.setXcoreElement(xPackage);
         }
       }
     }
     if (!_matched) {
       if (genElement instanceof GenClass) {
         final GenClass _genClass = (GenClass) genElement;
         _matched = true;
         EClass _ecoreClass = _genClass.getEcoreClass();
         ToXcoreMapping _toXcoreMapping = this.mapper.getToXcoreMapping(_ecoreClass);
         XNamedElement _xcoreElement = _toXcoreMapping.getXcoreElement();
         final XClass xClass = ((XClass) _xcoreElement);
         boolean _notEquals = (!Objects.equal(xClass, null));
         if (_notEquals) {
           XClassMapping _mapping = this.mapper.getMapping(xClass);
           _mapping.setGenClass(_genClass);
           ToXcoreMapping _toXcoreMapping_1 = this.mapper.getToXcoreMapping(_genClass);
           _toXcoreMapping_1.setXcoreElement(xClass);
         }
       }
     }
     if (!_matched) {
       if (genElement instanceof GenDataType) {
         final GenDataType _genDataType = (GenDataType) genElement;
         _matched = true;
         EDataType _ecoreDataType = _genDataType.getEcoreDataType();
         ToXcoreMapping _toXcoreMapping = this.mapper.getToXcoreMapping(_ecoreDataType);
         XNamedElement _xcoreElement = _toXcoreMapping.getXcoreElement();
         final XDataType xDataType = ((XDataType) _xcoreElement);
         boolean _notEquals = (!Objects.equal(xDataType, null));
         if (_notEquals) {
           XDataTypeMapping _mapping = this.mapper.getMapping(xDataType);
           _mapping.setGenDataType(_genDataType);
           ToXcoreMapping _toXcoreMapping_1 = this.mapper.getToXcoreMapping(_genDataType);
           _toXcoreMapping_1.setXcoreElement(xDataType);
         }
       }
     }
     if (!_matched) {
       if (genElement instanceof GenFeature) {
         final GenFeature _genFeature = (GenFeature) genElement;
         _matched = true;
         EStructuralFeature _ecoreFeature = _genFeature.getEcoreFeature();
         ToXcoreMapping _toXcoreMapping = this.mapper.getToXcoreMapping(_ecoreFeature);
         XNamedElement _xcoreElement = _toXcoreMapping.getXcoreElement();
         final XStructuralFeature xFeature = ((XStructuralFeature) _xcoreElement);
         boolean _notEquals = (!Objects.equal(xFeature, null));
         if (_notEquals) {
           XFeatureMapping _mapping = this.mapper.getMapping(xFeature);
           _mapping.setGenFeature(_genFeature);
           ToXcoreMapping _toXcoreMapping_1 = this.mapper.getToXcoreMapping(_genFeature);
           _toXcoreMapping_1.setXcoreElement(xFeature);
         }
       }
     }
     if (!_matched) {
       if (genElement instanceof GenOperation) {
         final GenOperation _genOperation = (GenOperation) genElement;
         _matched = true;
         EOperation _ecoreOperation = _genOperation.getEcoreOperation();
         ToXcoreMapping _toXcoreMapping = this.mapper.getToXcoreMapping(_ecoreOperation);
         XNamedElement _xcoreElement = _toXcoreMapping.getXcoreElement();
         final XOperation xOperation = ((XOperation) _xcoreElement);
         boolean _notEquals = (!Objects.equal(xOperation, null));
         if (_notEquals) {
           XOperationMapping _mapping = this.mapper.getMapping(xOperation);
           _mapping.setGenOperation(_genOperation);
           ToXcoreMapping _toXcoreMapping_1 = this.mapper.getToXcoreMapping(_genOperation);
           _toXcoreMapping_1.setXcoreElement(xOperation);
         }
       }
     }
     if (!_matched) {
       if (genElement instanceof GenParameter) {
         final GenParameter _genParameter = (GenParameter) genElement;
         _matched = true;
         EParameter _ecoreParameter = _genParameter.getEcoreParameter();
         ToXcoreMapping _toXcoreMapping = this.mapper.getToXcoreMapping(_ecoreParameter);
         XNamedElement _xcoreElement = _toXcoreMapping.getXcoreElement();
         final XParameter xParameter = ((XParameter) _xcoreElement);
         boolean _notEquals = (!Objects.equal(xParameter, null));
         if (_notEquals) {
           XParameterMapping _mapping = this.mapper.getMapping(xParameter);
           _mapping.setGenParameter(_genParameter);
           ToXcoreMapping _toXcoreMapping_1 = this.mapper.getToXcoreMapping(_genParameter);
           _toXcoreMapping_1.setXcoreElement(xParameter);
         }
       }
     }
     if (!_matched) {
       if (genElement instanceof GenTypeParameter) {
         final GenTypeParameter _genTypeParameter = (GenTypeParameter) genElement;
         _matched = true;
         ETypeParameter _ecoreTypeParameter = _genTypeParameter.getEcoreTypeParameter();
         ToXcoreMapping _toXcoreMapping = this.mapper.getToXcoreMapping(_ecoreTypeParameter);
         XNamedElement _xcoreElement = _toXcoreMapping.getXcoreElement();
         final XTypeParameter xTypeParameter = ((XTypeParameter) _xcoreElement);
         boolean _notEquals = (!Objects.equal(xTypeParameter, null));
         if (_notEquals) {
           XTypeParameterMapping _mapping = this.mapper.getMapping(xTypeParameter);
           _mapping.setGenTypeParameter(_genTypeParameter);
           ToXcoreMapping _toXcoreMapping_1 = this.mapper.getToXcoreMapping(_genTypeParameter);
           _toXcoreMapping_1.setXcoreElement(xTypeParameter);
         }
       }
     }
     if (!_matched) {
       if (genElement instanceof GenEnumLiteral) {
         final GenEnumLiteral _genEnumLiteral = (GenEnumLiteral) genElement;
         _matched = true;
         EEnumLiteral _ecoreEnumLiteral = _genEnumLiteral.getEcoreEnumLiteral();
         ToXcoreMapping _toXcoreMapping = this.mapper.getToXcoreMapping(_ecoreEnumLiteral);
         XNamedElement _xcoreElement = _toXcoreMapping.getXcoreElement();
         final XEnumLiteral xEnumLiteral = ((XEnumLiteral) _xcoreElement);
         boolean _notEquals = (!Objects.equal(xEnumLiteral, null));
         if (_notEquals) {
           XEnumLiteralMapping _mapping = this.mapper.getMapping(xEnumLiteral);
           _mapping.setGenEnumLiteral(_genEnumLiteral);
           ToXcoreMapping _toXcoreMapping_1 = this.mapper.getToXcoreMapping(_genEnumLiteral);
           _toXcoreMapping_1.setXcoreElement(xEnumLiteral);
         }
       }
     }
   }
 }
 public void initializeUsedGenPackages(final GenModel genModel) {
   this.genModelInitializer.initialize(genModel, true);
   HashSet<EPackage> _hashSet = new HashSet<EPackage>();
   final HashSet<EPackage> referencedEPackages = _hashSet;
   UniqueEList<EPackage> _uniqueEList = new UniqueEList<EPackage>();
   final List<EPackage> ePackages = _uniqueEList;
   EList<GenPackage> _genPackages = genModel.getGenPackages();
   for (final GenPackage genPackage : _genPackages) {
     EPackage _ecorePackage = genPackage.getEcorePackage();
     ePackages.add(_ecorePackage);
   }
   int i = 0;
   int _size = ePackages.size();
   boolean _lessThan = (i < _size);
   boolean _while = _lessThan;
   while (_while) {
     {
       final EPackage ePackage = ePackages.get(i);
       int _plus = (i + 1);
       i = _plus;
       final TreeIterator<EObject> allContents = ePackage.eAllContents();
       boolean _hasNext = allContents.hasNext();
       boolean _while_1 = _hasNext;
       while (_while_1) {
         {
           final EObject eObject = allContents.next();
           if ((eObject instanceof EPackage)) {
             allContents.prune();
           } else {
             EList<EObject> _eCrossReferences = eObject.eCrossReferences();
             for (final EObject eCrossReference : _eCrossReferences) {
               boolean _matched = false;
               if (!_matched) {
                 if (eCrossReference instanceof EClassifier) {
                   final EClassifier _eClassifier = (EClassifier) eCrossReference;
                   _matched = true;
                   final EPackage referencedEPackage = _eClassifier.getEPackage();
                   ePackages.add(referencedEPackage);
                   referencedEPackages.add(referencedEPackage);
                 }
               }
               if (!_matched) {
                 if (eCrossReference instanceof EStructuralFeature) {
                   final EStructuralFeature _eStructuralFeature =
                       (EStructuralFeature) eCrossReference;
                   _matched = true;
                   EClass _eContainingClass = _eStructuralFeature.getEContainingClass();
                   final EPackage referencedEPackage = _eContainingClass.getEPackage();
                   ePackages.add(referencedEPackage);
                   referencedEPackages.add(referencedEPackage);
                 }
               }
             }
           }
         }
         boolean _hasNext_1 = allContents.hasNext();
         _while_1 = _hasNext_1;
       }
     }
     int _size_1 = ePackages.size();
     boolean _lessThan_1 = (i < _size_1);
     _while = _lessThan_1;
   }
   for (final EPackage referencedEPackage : referencedEPackages) {
     GenPackage _findGenPackage = genModel.findGenPackage(referencedEPackage);
     boolean _equals = Objects.equal(_findGenPackage, null);
     if (_equals) {
       ToXcoreMapping _toXcoreMapping = this.mapper.getToXcoreMapping(referencedEPackage);
       XNamedElement _xcoreElement = _toXcoreMapping.getXcoreElement();
       GenBase _gen = this.mapper.getGen(_xcoreElement);
       GenPackage usedGenPackage = ((GenPackage) _gen);
       boolean _equals_1 = Objects.equal(usedGenPackage, null);
       if (_equals_1) {
         GenPackage _findLocalGenPackage = this.findLocalGenPackage(referencedEPackage);
         usedGenPackage = _findLocalGenPackage;
       }
       boolean _notEquals = (!Objects.equal(usedGenPackage, null));
       if (_notEquals) {
         EList<GenPackage> _usedGenPackages = genModel.getUsedGenPackages();
         _usedGenPackages.add(usedGenPackage);
       } else {
         Resource _eResource = genModel.eResource();
         ResourceSet _resourceSet = _eResource.getResourceSet();
         final EList<Resource> resources = _resourceSet.getResources();
         i = 0;
         boolean found = false;
         boolean _and = false;
         int _size_1 = resources.size();
         boolean _lessThan_1 = (i < _size_1);
         if (!_lessThan_1) {
           _and = false;
         } else {
           boolean _not = (!found);
           _and = (_lessThan_1 && _not);
         }
         boolean _while_1 = _and;
         while (_while_1) {
           {
             final Resource resource = resources.get(i);
             boolean _and_1 = false;
             URI _uRI = resource.getURI();
             String _fileExtension = _uRI.fileExtension();
             boolean _equals_2 = "genmodel".equals(_fileExtension);
             if (!_equals_2) {
               _and_1 = false;
             } else {
               EList<EObject> _contents = resource.getContents();
               boolean _isEmpty = _contents.isEmpty();
               boolean _not_1 = (!_isEmpty);
               _and_1 = (_equals_2 && _not_1);
             }
             if (_and_1) {
               EList<EObject> _contents_1 = resource.getContents();
               EObject _get = _contents_1.get(0);
               GenPackage _findGenPackage_1 = ((GenModel) _get).findGenPackage(referencedEPackage);
               usedGenPackage = _findGenPackage_1;
               boolean _notEquals_1 = (!Objects.equal(usedGenPackage, null));
               if (_notEquals_1) {
                 EList<GenPackage> _usedGenPackages_1 = genModel.getUsedGenPackages();
                 _usedGenPackages_1.add(usedGenPackage);
                 found = true;
               }
             }
             int _plus = (i + 1);
             i = _plus;
           }
           boolean _and_1 = false;
           int _size_2 = resources.size();
           boolean _lessThan_2 = (i < _size_2);
           if (!_lessThan_2) {
             _and_1 = false;
           } else {
             boolean _not_1 = (!found);
             _and_1 = (_lessThan_2 && _not_1);
           }
           _while_1 = _and_1;
         }
         boolean _not_1 = (!found);
         if (_not_1) {
           String _plus = ("No GenPackage found for " + referencedEPackage);
           RuntimeException _runtimeException = new RuntimeException(_plus);
           throw _runtimeException;
         }
       }
     }
   }
 }
Exemple #10
0
 private static String getQualifiedName(final EPackage epackage, final ResourceSet resourceSet) {
   GenPackage _genPackage = GenModelUtil2.getGenPackage(epackage, resourceSet);
   return _genPackage.getQualifiedPackageInterfaceName();
 }
 private void collectGenPackagesRequiredPluginIDs(
     Collection<GenPackage> genPackages, Set<String> pluginIDs) {
   for (GenPackage nextPackage : genPackages) {
     pluginIDs.add(nextPackage.getGenModel().getModelPluginID());
   }
 }
 public static String getJhipsterPackageName(GenPackage genPackage) {
   String basePackage = genPackage.getInterfacePackageName();
   return basePackage.length() > 0 ? basePackage + ".jhpister" : "Jhipster";
 }
  public void propagateEOperations(JavaResource resource, GenClass genClass) {
    GenPackage genPackage = genClass.getGenPackage();
    EPackage ePackage = genPackage.getEcorePackage();
    if (resource.getContents().isEmpty()
        || !(resource.getContents().get(0) instanceof CompilationUnit)) {
      return;
    }
    CompilationUnit cu = (CompilationUnit) resource.getContents().get(0);
    Class customClass = (Class) cu.getClassifiers().get(0);
    EClass eClass = genClass.getEcoreClass();

    if (eClass == null) {
      return;
    }

    Set<Method> annotatedMethods = getAnnotatedMethods(customClass);

    for (Method method : annotatedMethods) {
      for (AnnotationInstanceOrModifier modifier : method.getAnnotationsAndModifiers()) {
        if (modifier instanceof Public) {
          EOperation newEOperation = EcoreFactory.eINSTANCE.createEOperation();
          newEOperation.setName(method.getName());
          Type opType = method.getTypeReference().getTarget();
          newEOperation.setEType(
              eClassifierForCustomClass(opType, method.getTypeReference(), ePackage));
          if (isMulti(opType)) {
            newEOperation.setUpperBound(-1);
          }
          for (Parameter parameter : method.getParameters()) {
            EParameter newEParameter = EcoreFactory.eINSTANCE.createEParameter();
            newEParameter.setName(parameter.getName());
            Type paramType = parameter.getTypeReference().getTarget();
            newEParameter.setEType(
                eClassifierForCustomClass(paramType, parameter.getTypeReference(), ePackage));
            // TODO generics, ...
            newEOperation.getEParameters().add(newEParameter);
          }
          // TODO @jendrik: why is that needed?
          //					for (AnnotationInstanceOrModifier annotationInstance :
          // method.getAnnotationsAndModifiers()) {
          //						if (annotationInstance instanceof AnnotationInstance) {
          //							Classifier javaAnnotation = ((AnnotationInstance)
          // annotationInstance).getAnnotation();
          //							if (javaAnnotation.eIsProxy()) {
          //								continue;
          //							}
          //							EAnnotation eAnnotation = EcoreFactory.eINSTANCE.createEAnnotation();
          //							eAnnotation.setSource(javaAnnotation.getContainingCompilationUnit(
          //									).getNamespacesAsString() + javaAnnotation.getName());
          //							newEOperation.getEAnnotations().add(eAnnotation);
          //						}
          //					}
          boolean operationAlreadyExists = false;
          List<EOperation> operations = eClass.getEOperations();
          List<EOperation> existingOperations = new ArrayList<EOperation>(operations);
          // must be done here already for ensuring that compared operations have the same parent
          eClass.getEOperations().add(newEOperation);
          for (EOperation existingOperation : existingOperations) {
            boolean removed = removeAnnotation(existingOperation);
            if (EcoreUtil.equals(existingOperation, newEOperation)) {
              operationAlreadyExists = true;
              removeAnnotation(existingOperation);
              annotateAsGenerated(existingOperation);
              break;
            }
            if (removed) {
              annotateAsGenerated(existingOperation);
            }
          }
          if (!operationAlreadyExists) {
            annotateAsGenerated(newEOperation);
          } else {
            eClass.getEOperations().remove(newEOperation);
          }
          break;
        }
      }
    }

    try {
      Resource ecoreResource = ePackage.eResource();
      URI originalURI = ecoreResource.getURI();
      if (originalURI.isFile()) {
        String workspacePath = ResourcesPlugin.getWorkspace().getRoot().getLocation().toString();
        URI platformURI =
            URI.createPlatformResourceURI(
                originalURI.toFileString().substring(workspacePath.length()), true);
        ecoreResource.setURI(platformURI);
      }
      new ResourceSaver().saveResource(ecoreResource);
      ecoreResource.setURI(originalURI);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }