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;
}
}
}
}
}
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();
}
}
