From a6d7d250fef92528fdce0ed61604c27d122decaf Mon Sep 17 00:00:00 2001 From: Ivan Gomes Date: Sun, 27 Feb 2022 19:53:16 -0500 Subject: [PATCH 1/3] ST5AS-183 named API extension --- app/controllers/CommitController.java | 15 +- app/controllers/ElementController.java | 7 +- app/dao/CommitDao.java | 2 + app/dao/DataDao.java | 2 +- app/dao/ElementDao.java | 2 + app/dao/impl/jpa/JpaCommitDao.java | 135 +++++++++++++----- app/dao/impl/jpa/JpaDataDao.java | 108 +++++++------- app/dao/impl/jpa/JpaElementDao.java | 91 ++++++++---- app/dao/impl/jpa/JpaRelationshipDao.java | 5 +- app/jackson/DataDeserializer.java | 24 +++- app/jackson/DataSerializer.java | 4 +- app/jackson/RecordSerialization.java | 2 +- .../omg/sysml/data/impl/ExternalDataImpl.java | 6 +- .../data/impl/ExternalRelationshipImpl.java | 6 +- .../omg/sysml/data/impl/ProjectUsageImpl.java | 6 +- ...Index.java => CommitDataVersionIndex.java} | 6 +- .../internal/CommitNamedElementIndex.java | 19 +++ ...l.java => CommitDataVersionIndexImpl.java} | 14 +- .../impl/CommitNamedElementIndexImpl.java | 54 +++++++ app/org/omg/sysml/lifecycle/DataVersion.java | 4 + app/org/omg/sysml/metamodel/SysMLType.java | 2 + .../sysml/metamodel/impl/SysMLTypeImpl.java | 6 +- app/org/omg/sysml/record/impl/RecordImpl.java | 6 +- app/services/CommitService.java | 11 +- app/services/ElementService.java | 11 +- conf/META-INF/persistence.xml | 5 +- conf/routes | 4 + ....java => CommitDataVersionIndexImpl_.java} | 12 +- .../impl/CommitNamedElementIndexImpl_.java | 24 ++++ public/swagger/openapi.yaml | 82 +++++++++++ 30 files changed, 511 insertions(+), 164 deletions(-) rename app/org/omg/sysml/internal/{CommitIndex.java => CommitDataVersionIndex.java} (88%) create mode 100644 app/org/omg/sysml/internal/CommitNamedElementIndex.java rename app/org/omg/sysml/internal/impl/{CommitIndexImpl.java => CommitDataVersionIndexImpl.java} (82%) create mode 100644 app/org/omg/sysml/internal/impl/CommitNamedElementIndexImpl.java rename generated/org/omg/sysml/internal/impl/{CommitIndexImpl_.java => CommitDataVersionIndexImpl_.java} (54%) create mode 100644 generated/org/omg/sysml/internal/impl/CommitNamedElementIndexImpl_.java diff --git a/app/controllers/CommitController.java b/app/controllers/CommitController.java index cb0dc00d..83e9be36 100644 --- a/app/controllers/CommitController.java +++ b/app/controllers/CommitController.java @@ -55,13 +55,21 @@ public CommitController(CommitService commitService, MetamodelProvider metamodel } public Result postCommitByProject(UUID projectId, @SuppressWarnings("OptionalUsedAsFieldOrParameterType") Optional branchId, Request request) { + return postCommitByProject(projectId, branchId, request, commitService::create); + } + + public Result postCommitByProjectNameResolved(UUID projectId, @SuppressWarnings("OptionalUsedAsFieldOrParameterType") Optional branchId, Request request) { + return postCommitByProject(projectId, branchId, request, commitService::createNameResolved); + } + + private Result postCommitByProject(UUID projectId, @SuppressWarnings("OptionalUsedAsFieldOrParameterType") Optional branchId, Request request, CommitCreator creator) { JsonNode requestBodyJson = request.body().asJson(); Commit requestedObject = Json.fromJson(requestBodyJson, metamodelProvider.getImplementationClass(Commit.class)); if (requestedObject.getId() != null || requestedObject.getTimestamp() != null) { return Results.badRequest(); } requestedObject.setTimestamp(ZonedDateTime.now()); - Optional commit = commitService.create(projectId, branchId.orElse(null), requestedObject); + Optional commit = creator.create(projectId, branchId.orElse(null), requestedObject); if (commit.isEmpty()) { return Results.internalServerError(); } @@ -119,4 +127,9 @@ public Result getCommitByProjectAndId(UUID projectId, UUID commitId, Request req protected JsonLdAdorner getAdorner() { return adorner; } + + @FunctionalInterface + private interface CommitCreator { + Optional create(UUID projectId, UUID branchId, Commit commit); + } } diff --git a/app/controllers/ElementController.java b/app/controllers/ElementController.java index e8663aa7..f0052d6a 100644 --- a/app/controllers/ElementController.java +++ b/app/controllers/ElementController.java @@ -56,7 +56,7 @@ public Result getElementsByProjectIdCommitId(UUID projectId, UUID commitId, Requ } public Result getElementByProjectIdCommitIdElementId(UUID projectId, UUID commitId, UUID elementId, Request request) { - Optional element = elementService.getElementsByProjectIdCommitIdElementId(projectId, commitId, elementId); + Optional element = elementService.getElementByProjectIdCommitIdElementId(projectId, commitId, elementId); return buildResult(element.orElse(null), request, new DataJsonLdAdorner.Parameters(projectId, commitId)); } @@ -66,6 +66,11 @@ public Result getRootsByProjectIdCommitId(UUID projectId, UUID commitId, Request return buildPaginatedResult(roots, projectId, commitId, request, pageRequest); } + public Result getElementByProjectIdCommitIdQualifiedName(UUID projectId, UUID commitId, String qualifiedName, Request request) { + Optional element = elementService.getElementByProjectIdCommitIdQualifiedName(projectId, commitId, qualifiedName); + return buildResult(element.orElse(null), request, new DataJsonLdAdorner.Parameters(projectId, commitId)); + } + private Result buildPaginatedResult(List elements, UUID projectId, UUID commitId, Request request, PageRequest pageRequest) { return paginateResult( buildResult(elements, List.class, metamodelProvider.getImplementationClass(Element.class), request, new DataJsonLdAdorner.Parameters(projectId, commitId)), diff --git a/app/dao/CommitDao.java b/app/dao/CommitDao.java index e203e971..59e380d2 100644 --- a/app/dao/CommitDao.java +++ b/app/dao/CommitDao.java @@ -38,6 +38,8 @@ default Optional persist(Commit commit) { Optional persist(Commit commit, Branch branch); + Optional persistNameResolved(Commit commit, Branch branch); + @Override default Optional update(Commit commit) { throw new UnsupportedOperationException(); diff --git a/app/dao/DataDao.java b/app/dao/DataDao.java index 54cd0ba1..42aca2b4 100644 --- a/app/dao/DataDao.java +++ b/app/dao/DataDao.java @@ -26,7 +26,7 @@ import java.util.List; -public interface DataDao extends Dao { +public interface DataDao { List findByCommitAndQuery(Commit commit, Query query); } diff --git a/app/dao/ElementDao.java b/app/dao/ElementDao.java index ee346181..c6bf4035 100644 --- a/app/dao/ElementDao.java +++ b/app/dao/ElementDao.java @@ -37,4 +37,6 @@ public interface ElementDao extends Dao { Optional findByCommitAndId(Commit commit, UUID id); List findRootsByCommit(Commit commit, @Nullable UUID after, @Nullable UUID before, int maxResults); + + Optional findByCommitAndQualifiedName(Commit commit, String qualifiedName); } diff --git a/app/dao/impl/jpa/JpaCommitDao.java b/app/dao/impl/jpa/JpaCommitDao.java index a06df449..7e1fbc40 100644 --- a/app/dao/impl/jpa/JpaCommitDao.java +++ b/app/dao/impl/jpa/JpaCommitDao.java @@ -27,8 +27,12 @@ import javabean.JavaBeanHelper; import jpa.manager.JPAManager; import org.omg.sysml.lifecycle.*; -import org.omg.sysml.lifecycle.impl.*; +import org.omg.sysml.lifecycle.impl.CommitImpl; +import org.omg.sysml.lifecycle.impl.CommitImpl_; +import org.omg.sysml.lifecycle.impl.DataIdentityImpl; +import org.omg.sysml.lifecycle.impl.DataImpl; import org.omg.sysml.metamodel.Element; +import org.omg.sysml.metamodel.impl.ElementImpl_; import javax.inject.Inject; import javax.inject.Singleton; @@ -41,28 +45,17 @@ import javax.persistence.criteria.Root; import java.lang.reflect.Method; import java.util.*; +import java.util.function.BiFunction; +import java.util.function.Consumer; import java.util.function.Function; -import java.util.function.Supplier; -import java.util.function.UnaryOperator; import java.util.stream.Collectors; -import java.util.stream.Stream; + +import static jackson.RecordSerialization.IDENTITY_FIELD; +import static org.omg.sysml.metamodel.impl.ElementImpl_.QUALIFIED_NAME; @Singleton public class JpaCommitDao extends SimpleJpaDao implements CommitDao { - // TODO Explore alternative to serializing lazy entity attributes that doesn't involve resolving all proxies one level. - static UnaryOperator PROXY_RESOLVER = commit -> { - commit.getChange().stream() - .filter(Objects::nonNull) - .map(DataVersion::getPayload) - .filter(data -> data instanceof Element) - .map(data -> (Element) data) - .map(JpaElementDao.PROXY_RESOLVER) - .forEach(e -> { - }); - return commit; - }; - private final ElementDao elementDao; private final JpaBranchDao branchDao; @@ -73,8 +66,82 @@ public JpaCommitDao(JPAManager jpaManager, ElementDao elementDao, JpaBranchDao b this.branchDao = branchDao; } + // TODO Explore alternative to serializing lazy entity attributes that doesn't involve resolving all proxies one level. + protected static Commit resolve(Commit commit) { + commit.getChange().stream() + .filter(Objects::nonNull) + .map(DataVersion::getPayload) + .map(data -> JpaDataDao.resolve(data, Data.class)) + .forEach(e -> { + }); + return commit; + } + @Override public Optional persist(Commit commit, Branch branch) { + return persist(commit, branch, + fnData -> { + if (fnData.getId() == null) { + throw new IllegalArgumentException(String.format("Element must be referenced by %s", IDENTITY_FIELD)); + } + }, + (fnData, fnCache) -> Optional.ofNullable(fnCache.get(fnData.getId())), + (fnData, fnCommit) -> { + UUID id = fnData.getId(); + // TODO change to dataDao + return elementDao.findByCommitAndId(fnCommit, id) + .orElseThrow(() -> new NoSuchElementException( + String.format("Element with %s %s not found", IDENTITY_FIELD, id) + )); + } + ); + } + + @Override + public Optional persistNameResolved(Commit commit, Branch branch) { + return persist(commit, branch, + fnData -> { + if (fnData.getId() == null && (!(fnData instanceof Element) || ((Element) fnData).getQualifiedName() == null)) { + throw new IllegalArgumentException(String.format("Element must be referenced by %s or %s", IDENTITY_FIELD, QUALIFIED_NAME)); + } + }, + (fnData, fnCache) -> { + if (fnData.getId() != null) { + return Optional.ofNullable(fnCache.get(fnData.getId())); + } + else { + return fnCache.values().stream() + .filter(cached -> cached instanceof Element) + .map(cached -> (Element) cached) + .filter(cached -> ((Element) fnData).getQualifiedName().equals(cached.getQualifiedName())) + .map(cached -> (Data) cached) + .findFirst(); + } + }, + (fnData, fnCommit) -> { + if (fnData.getId() != null) { + UUID id = fnData.getId(); + // TODO change to dataDao + return elementDao.findByCommitAndId(fnCommit, id) + .orElseThrow(() -> new NoSuchElementException( + String.format("Element with %s %s not found", IDENTITY_FIELD, id) + )); + } + else { + String qualifiedName = ((Element) fnData).getQualifiedName(); + return elementDao.findByCommitAndQualifiedName(fnCommit, qualifiedName) + .orElseThrow(() -> new NoSuchElementException( + String.format("Element with %s %s not found", QUALIFIED_NAME, qualifiedName) + )); + } + }); + } + + private Optional persist( + Commit commit, Branch branch, + Consumer validator, + BiFunction, Optional> cacheResolver, + BiFunction commitResolver) { commit.setPreviousCommit(null); if (branch.getHead() != null) { commit.setPreviousCommit(branch.getHead()); @@ -94,12 +161,8 @@ public void setId(UUID id) { } }; - Supplier> changeStream = () -> commit.getChange().stream() - .filter(change -> change instanceof DataVersionImpl) - .map(change -> (DataVersionImpl) change); - // Give all Commit#changes an identity, if they don't already have one, and all Commit#changes#identity an id, if they don't already have one. - changeStream.get() + commit.getChange().stream() .peek(change -> change.setIdentity(change.getIdentity() != null ? change.getIdentity() : new DataIdentityImpl())) .map(DataVersion::getIdentity) .filter(identity -> identity instanceof DataIdentityImpl) @@ -107,7 +170,7 @@ public void setId(UUID id) { .forEach(identity -> identity.setId(identity.getId() != null ? identity.getId() : UUID.randomUUID())); // Copy all Commit#change#identity#id to Commit#change#payload#id and assign Commit#change#payload#key to a random UUID - Map identifierToDataMap = changeStream.get() + Map identifierToDataMap = commit.getChange().stream() .peek(change -> { Data payload = change.getPayload(); if (payload == null) { @@ -125,20 +188,16 @@ public void setId(UUID id) { ); Function reattachDataFunction = data -> { - Data reattachedData = identifierToDataMap.computeIfAbsent(data.getId(), identifier -> { - if (commit.getPreviousCommit() == null) { - return tombstone; - } - return elementDao.findByCommitAndId(commit.getPreviousCommit(), identifier) - .map(element -> (Data) element) - .orElse(tombstone); - }); - if (Objects.equals(reattachedData, tombstone)) { - throw new IllegalArgumentException("Element with ID " + data.getId() + " not found"); - } - return reattachedData; + validator.accept(data); + return cacheResolver.apply(data, identifierToDataMap) + .map(fnData -> fnData != tombstone ? fnData : null) + .orElseGet(() -> { + Data resolved = commitResolver.apply(data, commit.getPreviousCommit()); + identifierToDataMap.put(resolved.getId(), resolved); + return resolved; + }); }; - changeStream.get() + commit.getChange().stream() .map(DataVersion::getPayload) .filter(Objects::nonNull) .forEach(data -> JavaBeanHelper.getBeanProperties(data).values().stream() @@ -222,7 +281,7 @@ else if (Collection.class.isAssignableFrom(type)) { branch.setHead(c); branchDao.update(branch, em); }); - return persistedCommit.map(PROXY_RESOLVER); + return persistedCommit.map(JpaCommitDao::resolve); }); } @@ -273,7 +332,7 @@ protected Optional findByProjectAndId(Project project, UUID id, EntityMa @Override public Optional findByProjectAndIdResolved(Project project, UUID id) { return jpaManager.transact(em -> { - return findByProjectAndId(project, id, em).map(PROXY_RESOLVER); + return findByProjectAndId(project, id, em).map(JpaCommitDao::resolve); }); } } diff --git a/app/dao/impl/jpa/JpaDataDao.java b/app/dao/impl/jpa/JpaDataDao.java index 3ab246ae..feba6ba2 100644 --- a/app/dao/impl/jpa/JpaDataDao.java +++ b/app/dao/impl/jpa/JpaDataDao.java @@ -20,14 +20,17 @@ package dao.impl.jpa; +import com.google.common.collect.Streams; import config.MetamodelProvider; import dao.DataDao; import javabean.JavaBeanHelper; import jpa.manager.JPAManager; import org.hibernate.Hibernate; import org.hibernate.proxy.HibernateProxy; -import org.omg.sysml.internal.CommitIndex; -import org.omg.sysml.internal.impl.CommitIndexImpl; +import org.omg.sysml.data.ProjectUsage; +import org.omg.sysml.internal.CommitDataVersionIndex; +import org.omg.sysml.internal.impl.CommitDataVersionIndexImpl; +import org.omg.sysml.internal.impl.CommitDataVersionIndexImpl_; import org.omg.sysml.internal.impl.CommitIndexImpl_; import org.omg.sysml.lifecycle.Commit; import org.omg.sysml.lifecycle.Data; @@ -37,7 +40,6 @@ import org.omg.sysml.query.*; import org.omg.sysml.query.impl.QueryImpl; -import javax.annotation.Nullable; import javax.inject.Inject; import javax.persistence.EntityManager; import javax.persistence.EntityTransaction; @@ -50,21 +52,23 @@ import java.util.concurrent.ConcurrentHashMap; import java.util.function.Function; import java.util.function.Predicate; -import java.util.function.UnaryOperator; import java.util.stream.Collectors; import java.util.stream.Stream; -public class JpaDataDao extends JpaDao implements DataDao { +public class JpaDataDao implements DataDao { // TODO Explore alternative to serializing lazy entity attributes that doesn't involve resolving all proxies one level. - protected static UnaryOperator PROXY_RESOLVER = data -> { - data = Hibernate.unproxy(data, Data.class); - JavaBeanHelper.getBeanPropertyValues(data).values().stream() + protected static D resolve(D data, Class clazz) { + if (data == null) { + return null; + } + D resolved = Hibernate.unproxy(data, clazz); + JavaBeanHelper.getBeanPropertyValues(resolved).values().stream() .flatMap(o -> o instanceof Collection ? ((Collection) o).stream() : Stream.of(o)).filter(o -> o instanceof Data) .map(o -> (Data) o).forEach(Hibernate::unproxy); - return data; - }; + return resolved; + } protected static List> SUPPORTED_PRIMITIVE_CONSTRAINT_CLASSES = Arrays.asList( Number.class, @@ -75,88 +79,86 @@ public class JpaDataDao extends JpaDao implements DataDao { @SuppressWarnings({"unchecked", "rawtypes"}) protected static Comparator UNSAFE_COMPARABLE_COMPARATOR = (o1, o2) -> ((Comparable) o1).compareTo(o2); + private final JPAManager jpaManager; private final MetamodelProvider metamodelProvider; @Inject public JpaDataDao(JPAManager jpaManager, MetamodelProvider metamodelProvider) { - super(jpaManager); + this.jpaManager = jpaManager; this.metamodelProvider = metamodelProvider; } - @Override - public Optional findById(UUID id) { - return Optional.empty(); - } - - @Override - public List findAll() { - return null; - } - - @Override - public List findAll(@Nullable UUID after, @Nullable UUID before, int maxResults) { - return null; - } - - @Override - public void deleteAll() { - - } - @Override public List findByCommitAndQuery(Commit commit, Query query) { return jpaManager.transact(em -> { // TODO Commit is detached at this point. This ternary mitigates by requerying for the Commit in this transaction. A better solution would be moving transaction handling up to service layer (supported by general wisdom) and optionally migrating to using Play's @Transactional/JPAApi. Pros would include removal of repetitive transaction handling at the DAO layer and ability to interface with multiple DAOs in the same transaction (consistent view). Cons include increased temptation to keep transaction open for longer than needed, e.g. during JSON serialization due to the convenience of @Transactional (deprecated in >= 2.8.x), and the service, a higher level of abstraction, becoming aware of transactions. An alternative would be DAO-to-DAO calls (generally discouraged) and delegating to non-transactional versions of methods. Commit c = em.contains(commit) ? commit : em.find(CommitImpl.class, commit.getId()); Query q = query.getId() == null || em.contains(query) ? query : em.find(QueryImpl.class, query.getId()); - return getCommitIndex(c, em).getWorkingDataVersions().stream() + return getCommitIndex(c, em).getWorkingDataVersion().stream() .filter(scope(q)) .map(DataVersion::getPayload) .filter(constrain(q.getWhere())) - .map(PROXY_RESOLVER) + .map(data -> JpaDataDao.resolve(data, Data.class)) .collect(Collectors.toList()); }); } - protected CommitIndex getCommitIndex(Commit commit, EntityManager em) { + protected CommitDataVersionIndex getCommitIndex(Commit commit, EntityManager em) { CriteriaBuilder builder = em.getCriteriaBuilder(); - CriteriaQuery query = builder.createQuery(CommitIndexImpl.class); - Root root = query.from(CommitIndexImpl.class); - query.select(root).where(builder.equal(root.get(CommitIndexImpl_.id), commit.getId())); - CommitIndex commitIndex = null; + CriteriaQuery query = builder.createQuery(CommitDataVersionIndexImpl.class); + Root root = query.from(CommitDataVersionIndexImpl.class); + query.select(root).where(builder.equal(root.get(CommitDataVersionIndexImpl_.id), commit.getId())); try { - commitIndex = em.createQuery(query).getSingleResult(); + return em.createQuery(query).getSingleResult(); } catch (NoResultException ignored) { } - if (commitIndex != null) { - return commitIndex; - } - commitIndex = new CommitIndexImpl(); - commitIndex.setCommit(commit); - commitIndex.setWorkingDataVersions(streamWorkingDataVersions(commit).collect(Collectors.toSet())); + CommitDataVersionIndex index = new CommitDataVersionIndexImpl(); + index.setCommit(commit); + index.setWorkingDataVersion(streamWorkingDataVersions(commit, em).collect(Collectors.toSet())); EntityTransaction transaction = em.getTransaction(); transaction.begin(); - em.persist(commitIndex); + em.persist(index); transaction.commit(); - return commitIndex; + return index; } - protected Stream streamWorkingDataVersions(Commit commit) { + protected Stream streamWorkingDataVersions(Commit commit, EntityManager em) { Set visitedIds = ConcurrentHashMap.newKeySet(); - Map> results = queryCommitTree(commit, + Set projectUsages = ConcurrentHashMap.newKeySet(); + Map> results = queryCommitTree(commit, c -> c.getChange().stream() - .filter(record -> record.getIdentity() != null && record.getIdentity().getId() != null && record.getPayload() != null) + .filter(record -> record.getIdentity() != null && record.getIdentity().getId() != null) .filter(record -> !visitedIds.contains(record.getIdentity().getId())) - .peek(record -> visitedIds.add(record.getIdentity().getId()))); - return results.values().stream().flatMap(Function.identity()); + .peek(record -> visitedIds.add(record.getIdentity().getId())) + .filter(record -> record.getPayload() != null) + .peek(record -> { + if (record.getPayload() instanceof ProjectUsage) { + projectUsages.add(((ProjectUsage) record.getPayload())); + } + }) + .collect(Collectors.toSet()) + ); + Stream ownedDataVersions = results.values().stream() + .flatMap(Set::stream); + Stream usedDataVersions = projectUsages.stream() + .map(ProjectUsage::getUsedProjectCommit) + .filter(Objects::nonNull) + .map(fnCommit -> getCommitIndex(fnCommit, em)) + .map(CommitDataVersionIndex::getWorkingDataVersion) + .flatMap(Set::stream) + .filter(record -> !visitedIds.contains(record.getIdentity().getId())) + .peek(record -> visitedIds.add(record.getIdentity().getId())) + .collect(Collectors.toSet()) + .stream(); + return Streams.concat(ownedDataVersions, usedDataVersions); } protected Map queryCommitTree(Commit commit, Function query) { return queryCommitTree(commit, query, t -> false); } - protected Map queryCommitTree(Commit commit, Function query, java.util.function.Predicate terminationCondition) { + protected Map queryCommitTree(Commit commit, Function query, Predicate terminationCondition) { Map results = new LinkedHashMap<>(); Commit currentCommit = commit; Set visitedCommits = new HashSet<>(); diff --git a/app/dao/impl/jpa/JpaElementDao.java b/app/dao/impl/jpa/JpaElementDao.java index 30bf0bd6..b554b909 100644 --- a/app/dao/impl/jpa/JpaElementDao.java +++ b/app/dao/impl/jpa/JpaElementDao.java @@ -24,12 +24,13 @@ import config.MetamodelProvider; import dao.ElementDao; -import javabean.JavaBeanHelper; import jpa.manager.JPAManager; -import org.hibernate.Hibernate; -import org.omg.sysml.internal.CommitIndex; -import org.omg.sysml.internal.impl.CommitIndexImpl; -import org.omg.sysml.internal.impl.CommitIndexImpl_; +import org.omg.sysml.internal.CommitDataVersionIndex; +import org.omg.sysml.internal.CommitNamedElementIndex; +import org.omg.sysml.internal.impl.CommitDataVersionIndexImpl; +import org.omg.sysml.internal.impl.CommitDataVersionIndexImpl_; +import org.omg.sysml.internal.impl.CommitNamedElementIndexImpl; +import org.omg.sysml.internal.impl.CommitNamedElementIndexImpl_; import org.omg.sysml.lifecycle.Commit; import org.omg.sysml.lifecycle.DataVersion; import org.omg.sysml.lifecycle.impl.*; @@ -41,24 +42,18 @@ import javax.annotation.Nullable; import javax.inject.Inject; import javax.inject.Singleton; +import javax.persistence.EntityManager; +import javax.persistence.EntityTransaction; import javax.persistence.NoResultException; import javax.persistence.TypedQuery; import javax.persistence.criteria.*; import java.util.*; -import java.util.function.UnaryOperator; +import java.util.function.Function; import java.util.stream.Collectors; import java.util.stream.Stream; @Singleton public class JpaElementDao extends JpaDao implements ElementDao { - // TODO Explore alternative to serializing lazy entity attributes that doesn't involve resolving all proxies one level. - static UnaryOperator PROXY_RESOLVER = element -> { - element = Hibernate.unproxy(element, Element.class); - JavaBeanHelper.getBeanPropertyValues(element).values().stream() - .flatMap(o -> o instanceof Collection ? ((Collection) o).stream() : Stream.of(o)).filter(o -> o instanceof Element) - .map(o -> (Element) o).forEach(Hibernate::unproxy); - return element; - }; private final Set> implementationClasses; private final JpaDataDao dataDao; @@ -140,15 +135,15 @@ public List findAllByCommit(Commit commit, @Nullable UUID after, @Nulla return jpaManager.transact(em -> { // TODO Commit is detached at this point. This ternary mitigates by requerying for the Commit in this transaction. A better solution would be moving transaction handling up to service layer (supported by general wisdom) and optionally migrating to using Play's @Transactional/JPAApi. Pros would include removal of repetitive transaction handling at the DAO layer and ability to interface with multiple DAOs in the same transaction (consistent view). Cons include increased temptation to keep transaction open for longer than needed, e.g. during JSON serialization due to the convenience of @Transactional (deprecated in >= 2.8.x), and the service, a higher level of abstraction, becoming aware of transactions. An alternative would be DAO-to-DAO calls (generally discouraged) and delegating to non-transactional versions of methods. Commit c = em.contains(commit) ? commit : em.find(CommitImpl.class, commit.getId()); - CommitIndex commitIndex = dataDao.getCommitIndex(c, em); + CommitDataVersionIndex commitIndex = dataDao.getCommitIndex(c, em); CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery query = builder.createQuery(DataVersionImpl.class); - Root commitIndexRoot = query.from(CommitIndexImpl.class); - SetJoin workingDataVersionsJoin = commitIndexRoot.join(CommitIndexImpl_.workingDataVersions); + Root commitIndexRoot = query.from(CommitDataVersionIndexImpl.class); + SetJoin workingDataVersionsJoin = commitIndexRoot.join(CommitDataVersionIndexImpl_.workingDataVersion); Join dataIdentityJoin = workingDataVersionsJoin.join(DataVersionImpl_.identity); Path idPath = dataIdentityJoin.get(DataIdentityImpl_.id); - Expression where = builder.equal(commitIndexRoot.get(CommitIndexImpl_.id), commitIndex.getId()); + Expression where = builder.equal(commitIndexRoot.get(CommitDataVersionIndexImpl_.id), commitIndex.getId()); query.select(workingDataVersionsJoin); Paginated> paginated = paginateQuery(after, before, maxResults, query, builder, em, idPath, where); List result = paginated.get() @@ -156,7 +151,7 @@ public List findAllByCommit(Commit commit, @Nullable UUID after, @Nulla .map(DataVersion::getPayload) .filter(data -> data instanceof Element) .map(data -> (Element) data) - .map(PROXY_RESOLVER) + .map(element -> JpaDataDao.resolve(element, Element.class)) .collect(Collectors.toList()); if (paginated.isReversed()) { Collections.reverse(result); @@ -170,23 +165,23 @@ public Optional findByCommitAndId(Commit commit, UUID id) { return jpaManager.transact(em -> { // TODO Commit is detached at this point. This ternary mitigates by requerying for the Commit in this transaction. A better solution would be moving transaction handling up to service layer (supported by general wisdom) and optionally migrating to using Play's @Transactional/JPAApi. Pros would include removal of repetitive transaction handling at the DAO layer and ability to interface with multiple DAOs in the same transaction (consistent view). Cons include increased temptation to keep transaction open for longer than needed, e.g. during JSON serialization due to the convenience of @Transactional (deprecated in >= 2.8.x), and the service, a higher level of abstraction, becoming aware of transactions. An alternative would be DAO-to-DAO calls (generally discouraged) and delegating to non-transactional versions of methods. Commit c = em.contains(commit) ? commit : em.find(CommitImpl.class, commit.getId()); - CommitIndex commitIndex = dataDao.getCommitIndex(c, em); + CommitDataVersionIndex commitIndex = dataDao.getCommitIndex(c, em); CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaQuery query = builder.createQuery(DataVersionImpl.class); - Root commitIndexRoot = query.from(CommitIndexImpl.class); - SetJoin workingDataVersionsJoin = commitIndexRoot.join(CommitIndexImpl_.workingDataVersions); - Join dataIdentityJoin = workingDataVersionsJoin.join(DataVersionImpl_.identity); + Root commitIndexRoot = query.from(CommitDataVersionIndexImpl.class); + SetJoin workingDataVersionsJoin = commitIndexRoot.join(CommitDataVersionIndexImpl_.workingDataVersion); + Join identityJoin = workingDataVersionsJoin.join(DataVersionImpl_.identity); query.select(workingDataVersionsJoin).where( - builder.equal(commitIndexRoot.get(CommitIndexImpl_.id), commitIndex.getId()), - builder.equal(dataIdentityJoin.get(DataIdentityImpl_.id), id) + builder.equal(commitIndexRoot.get(CommitDataVersionIndexImpl_.id), commitIndex.getId()), + builder.equal(identityJoin.get(DataIdentityImpl_.id), id) ); try { return Optional.of(em.createQuery(query).getSingleResult()) .map(DataVersion::getPayload) .filter(data -> data instanceof Element) .map(data -> (Element) data) - .map(PROXY_RESOLVER); + .map(element -> JpaDataDao.resolve(element, Element.class)); } catch (NoResultException e) { return Optional.empty(); } @@ -198,14 +193,14 @@ public List findRootsByCommit(Commit commit, @Nullable UUID after, @Nul return jpaManager.transact(em -> { // TODO Commit is detached at this point. This ternary mitigates by requerying for the Commit in this transaction. A better solution would be moving transaction handling up to service layer (supported by general wisdom) and optionally migrating to using Play's @Transactional/JPAApi. Pros would include removal of repetitive transaction handling at the DAO layer and ability to interface with multiple DAOs in the same transaction (consistent view). Cons include increased temptation to keep transaction open for longer than needed, e.g. during JSON serialization due to the convenience of @Transactional (deprecated in >= 2.8.x), and the service, a higher level of abstraction, becoming aware of transactions. An alternative would be DAO-to-DAO calls (generally discouraged) and delegating to non-transactional versions of methods. Commit c = em.contains(commit) ? commit : em.find(CommitImpl.class, commit.getId()); - Stream stream = dataDao.getCommitIndex(c, em).getWorkingDataVersions().stream() + Stream stream = dataDao.getCommitIndex(c, em).getWorkingDataVersion().stream() .map(DataVersion::getPayload) .filter(data -> (data instanceof Element) && !(data instanceof Relationship)) .map(data -> (Element) data) .filter(element -> element.getOwner() == null); Paginated> paginatedStream = paginateStream(after, before, maxResults, stream, Element::getIdentifier); List result = paginatedStream.get() - .map(PROXY_RESOLVER) + .map(element -> JpaDataDao.resolve(element, Element.class)) .collect(Collectors.toList()); if (paginatedStream.isReversed()) { Collections.reverse(result); @@ -214,6 +209,46 @@ public List findRootsByCommit(Commit commit, @Nullable UUID after, @Nul }); } + public Optional findByCommitAndQualifiedName(Commit commit, String qualifiedName) { + return jpaManager.transact(em -> { + // TODO Commit is detached at this point. This ternary mitigates by requerying for the Commit in this transaction. A better solution would be moving transaction handling up to service layer (supported by general wisdom) and optionally migrating to using Play's @Transactional/JPAApi. Pros would include removal of repetitive transaction handling at the DAO layer and ability to interface with multiple DAOs in the same transaction (consistent view). Cons include increased temptation to keep transaction open for longer than needed, e.g. during JSON serialization due to the convenience of @Transactional (deprecated in >= 2.8.x), and the service, a higher level of abstraction, becoming aware of transactions. An alternative would be DAO-to-DAO calls (generally discouraged) and delegating to non-transactional versions of methods. + Commit c = em.contains(commit) ? commit : em.find(CommitImpl.class, commit.getId()); + return Optional.ofNullable(getCommitNamedElementIndex(c, em).getWorkingNamedElement().get(qualifiedName)); + }); + } + + protected CommitNamedElementIndex getCommitNamedElementIndex(Commit commit, EntityManager em) { + CriteriaBuilder builder = em.getCriteriaBuilder(); + CriteriaQuery query = builder.createQuery(CommitNamedElementIndexImpl.class); + Root root = query.from(CommitNamedElementIndexImpl.class); + query.select(root).where(builder.equal(root.get(CommitNamedElementIndexImpl_.id), commit.getId())); + try { + return em.createQuery(query).getSingleResult(); + } catch (NoResultException ignored) { + } + + CommitNamedElementIndexImpl index = new CommitNamedElementIndexImpl(); + index.setCommit(commit); + index.setWorkingNamedElement( + streamWorkingElements(commit, em) + .filter(element -> Objects.nonNull(element.getQualifiedName())) + .collect(Collectors.toUnmodifiableMap(Element::getQualifiedName, + Function.identity(), (e1, e2) -> e1)) + ); + EntityTransaction transaction = em.getTransaction(); + transaction.begin(); + em.persist(index); + transaction.commit(); + return index; + } + + protected Stream streamWorkingElements(Commit commit, EntityManager em) { + return dataDao.getCommitIndex(commit, em).getWorkingDataVersion().stream() + .map(DataVersion::getPayload) + .filter(data -> data instanceof Element) + .map(data -> (Element) data); + } + private Expression getTypeExpression(CriteriaBuilder builder, Root root) { return builder.or(implementationClasses.stream() .map(c -> builder.equal(root.type(), c)) diff --git a/app/dao/impl/jpa/JpaRelationshipDao.java b/app/dao/impl/jpa/JpaRelationshipDao.java index 3865a009..d968aea2 100644 --- a/app/dao/impl/jpa/JpaRelationshipDao.java +++ b/app/dao/impl/jpa/JpaRelationshipDao.java @@ -127,7 +127,7 @@ public List findAllByCommitRelatedElement(Commit commit, Element r // Reverting to non-relational streaming // TODO Commit is detached at this point. This ternary mitigates by requerying for the Commit in this transaction. A better solution would be moving transaction handling up to service layer (supported by general wisdom) and optionally migrating to using Play's @Transactional/JPAApi. Pros would include removal of repetitive transaction handling at the DAO layer and ability to interface with multiple DAOs in the same transaction (consistent view). Cons include increased temptation to keep transaction open for longer than needed, e.g. during JSON serialization due to the convenience of @Transactional (deprecated in >= 2.8.x), and the service, a higher level of abstraction, becoming aware of transactions. An alternative would be DAO-to-DAO calls (generally discouraged) and delegating to non-transactional versions of methods. Commit c = em.contains(commit) ? commit : em.find(CommitImpl.class, commit.getId()); - Stream stream = dataDao.getCommitIndex(c, em).getWorkingDataVersions().stream() + Stream stream = dataDao.getCommitIndex(c, em).getWorkingDataVersion().stream() .map(DataVersion::getPayload).filter(data -> data instanceof Relationship) .map(data -> (Relationship) data) .filter(relationship -> { @@ -152,8 +152,7 @@ public List findAllByCommitRelatedElement(Commit commit, Element r ); Paginated> paginatedStream = paginateStream(after, before, maxResults, stream, Relationship::getIdentifier); List result = paginatedStream.get() - .map(JpaElementDao.PROXY_RESOLVER) - .map(data -> (Relationship) data) + .map(relationship -> JpaDataDao.resolve(relationship, Relationship.class)) .collect(Collectors.toList()); if (paginatedStream.isReversed()) { Collections.reverse(result); diff --git a/app/jackson/DataDeserializer.java b/app/jackson/DataDeserializer.java index a220af33..c7ff88a7 100644 --- a/app/jackson/DataDeserializer.java +++ b/app/jackson/DataDeserializer.java @@ -34,6 +34,7 @@ import com.fasterxml.jackson.databind.jsontype.TypeDeserializer; import javassist.util.proxy.ProxyFactory; import org.omg.sysml.lifecycle.Data; +import org.omg.sysml.metamodel.Element; import javax.persistence.EntityManager; import java.io.IOException; @@ -41,10 +42,13 @@ import java.util.Map; import java.util.UUID; +import static jackson.RecordSerialization.IDENTITY_FIELD; +import static org.omg.sysml.metamodel.impl.ElementImpl_.QUALIFIED_NAME; + public class DataDeserializer extends StdDeserializer implements ContextualDeserializer { - private static Map, Class> PROXY_MAP = new HashMap<>(); - private EntityManager entityManager; - private JavaType type; + private static final Map, Class> PROXY_MAP = new HashMap<>(); + private final EntityManager entityManager; + private final JavaType type; public DataDeserializer(EntityManager entityManager) { this(entityManager, null); @@ -81,9 +85,19 @@ public Data deserialize(JsonParser p, DeserializationContext ctxt) throws IOExce JsonToken token; while ((token = p.nextToken()) != null && token != JsonToken.END_OBJECT) { - if (token == JsonToken.FIELD_NAME && "@id".equals(p.getCurrentName())) { + if (token == JsonToken.FIELD_NAME) { + String name = p.getCurrentName(); p.nextToken(); - data.setId(UUID.fromString(p.getText())); + switch (name) { + case IDENTITY_FIELD: + data.setId(UUID.fromString(p.getText())); + break; + case QUALIFIED_NAME: + if (data instanceof Element) { + ((Element) data).setQualifiedName(p.getText()); + } + break; + } } } return data; diff --git a/app/jackson/DataSerializer.java b/app/jackson/DataSerializer.java index f12d58bc..16657ca2 100644 --- a/app/jackson/DataSerializer.java +++ b/app/jackson/DataSerializer.java @@ -30,6 +30,8 @@ import javax.persistence.PersistenceException; import java.io.IOException; +import static jackson.RecordSerialization.IDENTITY_FIELD; + // TODO inherit from JpaIdentitySerializer public class DataSerializer extends StdSerializer { public DataSerializer() { @@ -52,7 +54,7 @@ public void serialize(Data value, JsonGenerator gen, SerializerProvider provider return; } gen.writeStartObject(); - gen.writeObjectField("@id", value.getId()); + gen.writeObjectField(IDENTITY_FIELD, value.getId()); gen.writeEndObject(); } } \ No newline at end of file diff --git a/app/jackson/RecordSerialization.java b/app/jackson/RecordSerialization.java index 13dc5a47..d697262f 100644 --- a/app/jackson/RecordSerialization.java +++ b/app/jackson/RecordSerialization.java @@ -34,7 +34,7 @@ public class RecordSerialization { - private static final String IDENTITY_FIELD = "@id"; + public static final String IDENTITY_FIELD = "@id"; public static class RecordSerializer extends JpaIdentitySerializer { diff --git a/app/org/omg/sysml/data/impl/ExternalDataImpl.java b/app/org/omg/sysml/data/impl/ExternalDataImpl.java index c6e5ebdb..01b46e65 100644 --- a/app/org/omg/sysml/data/impl/ExternalDataImpl.java +++ b/app/org/omg/sysml/data/impl/ExternalDataImpl.java @@ -37,6 +37,8 @@ import java.net.URI; import java.util.UUID; +import static jackson.RecordSerialization.IDENTITY_FIELD; + @Entity(name = "ExternalDataImpl") @SecondaryTable(name = "ExternalData") @org.hibernate.annotations.Table(appliesTo = "ExternalData", fetch = FetchMode.SELECT, optional = false) @@ -48,12 +50,12 @@ public class ExternalDataImpl extends DataImpl implements ExternalData { private UUID id; @Column(name = "id", table = "ExternalData") - @JsonGetter(value = "@id") + @JsonGetter(value = IDENTITY_FIELD) public UUID getId() { return id; } - @JsonSetter(value = "@id") + @JsonSetter(value = IDENTITY_FIELD) public void setId(UUID id) { this.id = id; } diff --git a/app/org/omg/sysml/data/impl/ExternalRelationshipImpl.java b/app/org/omg/sysml/data/impl/ExternalRelationshipImpl.java index cad8003e..43003aab 100644 --- a/app/org/omg/sysml/data/impl/ExternalRelationshipImpl.java +++ b/app/org/omg/sysml/data/impl/ExternalRelationshipImpl.java @@ -41,6 +41,8 @@ import javax.persistence.*; import java.util.UUID; +import static jackson.RecordSerialization.IDENTITY_FIELD; + @Entity(name = "ExternalRelationshipImpl") @SecondaryTable(name = "ExternalRelationship") @org.hibernate.annotations.Table(appliesTo = "ExternalRelationship", fetch = FetchMode.SELECT, optional = false) @@ -52,12 +54,12 @@ public class ExternalRelationshipImpl extends DataImpl implements ExternalRelati private UUID id; @Column(name = "id", table = "ExternalRelationship") - @JsonGetter(value = "@id") + @JsonGetter(value = IDENTITY_FIELD) public UUID getId() { return id; } - @JsonSetter(value = "@id") + @JsonSetter(value = IDENTITY_FIELD) public void setId(UUID id) { this.id = id; } diff --git a/app/org/omg/sysml/data/impl/ProjectUsageImpl.java b/app/org/omg/sysml/data/impl/ProjectUsageImpl.java index 212c5fcc..c5b81ffe 100644 --- a/app/org/omg/sysml/data/impl/ProjectUsageImpl.java +++ b/app/org/omg/sysml/data/impl/ProjectUsageImpl.java @@ -40,6 +40,8 @@ import javax.persistence.*; import java.util.UUID; +import static jackson.RecordSerialization.IDENTITY_FIELD; + @Entity(name = "ProjectUsageImpl") @SecondaryTable(name = "ProjectUsage") @org.hibernate.annotations.Table(appliesTo = "ProjectUsage", fetch = FetchMode.SELECT, optional = false) @@ -51,12 +53,12 @@ public class ProjectUsageImpl extends DataImpl implements ProjectUsage { private UUID id; @Column(name = "id", table = "ProjectUsage") - @JsonGetter(value = "@id") + @JsonGetter(value = IDENTITY_FIELD) public UUID getId() { return id; } - @JsonSetter(value = "@id") + @JsonSetter(value = IDENTITY_FIELD) public void setId(UUID id) { this.id = id; } diff --git a/app/org/omg/sysml/internal/CommitIndex.java b/app/org/omg/sysml/internal/CommitDataVersionIndex.java similarity index 88% rename from app/org/omg/sysml/internal/CommitIndex.java rename to app/org/omg/sysml/internal/CommitDataVersionIndex.java index cf0162b5..fd731e63 100644 --- a/app/org/omg/sysml/internal/CommitIndex.java +++ b/app/org/omg/sysml/internal/CommitDataVersionIndex.java @@ -28,14 +28,14 @@ import java.util.Set; import java.util.UUID; -public interface CommitIndex { +public interface CommitDataVersionIndex { UUID getId(); Commit getCommit(); void setCommit(Commit commit); - Set getWorkingDataVersions(); + Set getWorkingDataVersion(); - void setWorkingDataVersions(Set elements); + void setWorkingDataVersion(Set workingDataVersion); } diff --git a/app/org/omg/sysml/internal/CommitNamedElementIndex.java b/app/org/omg/sysml/internal/CommitNamedElementIndex.java new file mode 100644 index 00000000..f1c43350 --- /dev/null +++ b/app/org/omg/sysml/internal/CommitNamedElementIndex.java @@ -0,0 +1,19 @@ +package org.omg.sysml.internal; + +import org.omg.sysml.lifecycle.Commit; +import org.omg.sysml.metamodel.Element; + +import java.util.Map; +import java.util.UUID; + +public interface CommitNamedElementIndex { + UUID getId(); + + Commit getCommit(); + + void setCommit(Commit commit); + + Map getWorkingNamedElement(); + + void setWorkingNamedElement(Map workingNamedElement); +} diff --git a/app/org/omg/sysml/internal/impl/CommitIndexImpl.java b/app/org/omg/sysml/internal/impl/CommitDataVersionIndexImpl.java similarity index 82% rename from app/org/omg/sysml/internal/impl/CommitIndexImpl.java rename to app/org/omg/sysml/internal/impl/CommitDataVersionIndexImpl.java index fdcb23bd..aaeceb94 100644 --- a/app/org/omg/sysml/internal/impl/CommitIndexImpl.java +++ b/app/org/omg/sysml/internal/impl/CommitDataVersionIndexImpl.java @@ -22,7 +22,7 @@ package org.omg.sysml.internal.impl; -import org.omg.sysml.internal.CommitIndex; +import org.omg.sysml.internal.CommitDataVersionIndex; import org.omg.sysml.lifecycle.Commit; import org.omg.sysml.lifecycle.DataVersion; import org.omg.sysml.lifecycle.impl.CommitImpl; @@ -33,10 +33,10 @@ import java.util.UUID; @Entity(name = "CommitIndex") -public class CommitIndexImpl implements CommitIndex { +public class CommitDataVersionIndexImpl implements CommitDataVersionIndex { private UUID id; private Commit commit; - private Set workingDataVersions; + private Set workingDataVersion; @Id public UUID getId() { @@ -62,12 +62,12 @@ public void setCommit(Commit commit) { @Override @ManyToMany(targetEntity = DataVersionImpl.class, fetch = FetchType.LAZY) - public Set getWorkingDataVersions() { - return workingDataVersions; + public Set getWorkingDataVersion() { + return workingDataVersion; } @Override - public void setWorkingDataVersions(Set workingDataVersions) { - this.workingDataVersions = workingDataVersions; + public void setWorkingDataVersion(Set workingDataVersion) { + this.workingDataVersion = workingDataVersion; } } diff --git a/app/org/omg/sysml/internal/impl/CommitNamedElementIndexImpl.java b/app/org/omg/sysml/internal/impl/CommitNamedElementIndexImpl.java new file mode 100644 index 00000000..6219c8ba --- /dev/null +++ b/app/org/omg/sysml/internal/impl/CommitNamedElementIndexImpl.java @@ -0,0 +1,54 @@ +package org.omg.sysml.internal.impl; + +import org.hibernate.annotations.ManyToAny; +import org.omg.sysml.internal.CommitNamedElementIndex; +import org.omg.sysml.lifecycle.Commit; +import org.omg.sysml.lifecycle.impl.CommitImpl; +import org.omg.sysml.metamodel.Element; +import org.omg.sysml.metamodel.impl.ElementImpl_; + +import javax.persistence.*; +import java.util.Map; +import java.util.UUID; + +@Entity(name = "CommitNamedElementIndex") +public class CommitNamedElementIndexImpl implements CommitNamedElementIndex { + private UUID id; + private Commit commit; + private Map workingNamedElement; + + @Id + public UUID getId() { + return id; + } + + public void setId(UUID id) { + this.id = id; + } + + @Override + @JoinColumn(name = "id") + @OneToOne(targetEntity = CommitImpl.class) + @MapsId + public Commit getCommit() { + return commit; + } + + @Override + public void setCommit(Commit commit) { + this.commit = commit; + } + + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @Column(name = "workingNamedElementType"), fetch = FetchType.LAZY) + @JoinTable(name = "CommitNamedElementIndex_workingNamedElement", + joinColumns = {@JoinColumn(name = "commitNamedElementIndexId")}, + inverseJoinColumns = {@JoinColumn(name = "workingNamedElementId")}) + @MapKeyColumn(name = ElementImpl_.QUALIFIED_NAME) + public Map getWorkingNamedElement() { + return workingNamedElement; + } + + public void setWorkingNamedElement(Map workingNamedElement) { + this.workingNamedElement = workingNamedElement; + } +} diff --git a/app/org/omg/sysml/lifecycle/DataVersion.java b/app/org/omg/sysml/lifecycle/DataVersion.java index a55d3e0b..8c70ed2c 100644 --- a/app/org/omg/sysml/lifecycle/DataVersion.java +++ b/app/org/omg/sysml/lifecycle/DataVersion.java @@ -30,5 +30,9 @@ public interface DataVersion extends Record { Data getPayload(); + void setPayload(Data payload); + DataIdentity getIdentity(); + + void setIdentity(DataIdentity identity); } diff --git a/app/org/omg/sysml/metamodel/SysMLType.java b/app/org/omg/sysml/metamodel/SysMLType.java index 8d0ab4b6..6a67f491 100644 --- a/app/org/omg/sysml/metamodel/SysMLType.java +++ b/app/org/omg/sysml/metamodel/SysMLType.java @@ -23,4 +23,6 @@ import org.omg.sysml.lifecycle.Data; public interface SysMLType extends Data { + + void setQualifiedName(String qualifiedName); } diff --git a/app/org/omg/sysml/metamodel/impl/SysMLTypeImpl.java b/app/org/omg/sysml/metamodel/impl/SysMLTypeImpl.java index d0690fd3..695a5ddb 100644 --- a/app/org/omg/sysml/metamodel/impl/SysMLTypeImpl.java +++ b/app/org/omg/sysml/metamodel/impl/SysMLTypeImpl.java @@ -29,6 +29,8 @@ import javax.persistence.Transient; +import static jackson.RecordSerialization.IDENTITY_FIELD; + public abstract class SysMLTypeImpl extends DataImpl implements Data { public abstract java.util.UUID getIdentifier(); @@ -36,12 +38,12 @@ public abstract class SysMLTypeImpl extends DataImpl implements Data { public abstract void setIdentifier(java.util.UUID identifier); @Transient - @JsonGetter(value = "@id") + @JsonGetter(value = IDENTITY_FIELD) public java.util.UUID getId() { return getIdentifier(); } - @JsonSetter(value = "@id") + @JsonSetter(value = IDENTITY_FIELD) public void setId(java.util.UUID id) { setIdentifier(id); } diff --git a/app/org/omg/sysml/record/impl/RecordImpl.java b/app/org/omg/sysml/record/impl/RecordImpl.java index ee1e592b..288ff7ac 100644 --- a/app/org/omg/sysml/record/impl/RecordImpl.java +++ b/app/org/omg/sysml/record/impl/RecordImpl.java @@ -32,6 +32,8 @@ import javax.persistence.MappedSuperclass; import java.util.UUID; +import static jackson.RecordSerialization.IDENTITY_FIELD; + @MappedSuperclass public abstract class RecordImpl implements Record { private UUID id; @@ -40,12 +42,12 @@ public abstract class RecordImpl implements Record { @Id @GeneratedValue(generator = "UseExistingOrGenerateUUIDGenerator") @Column(name = "id") - @JsonGetter(value = "@id") + @JsonGetter(value = IDENTITY_FIELD) public UUID getId() { return id; } - @JsonSetter(value = "@id") + @JsonSetter(value = IDENTITY_FIELD) public void setId(UUID id) { this.id = id; } diff --git a/app/services/CommitService.java b/app/services/CommitService.java index b83e8ec6..d0042c8d 100644 --- a/app/services/CommitService.java +++ b/app/services/CommitService.java @@ -34,6 +34,7 @@ import java.util.List; import java.util.Optional; import java.util.UUID; +import java.util.function.BiFunction; @Singleton public class CommitService extends BaseService { @@ -49,6 +50,14 @@ public CommitService(CommitDao commitDao, ProjectDao projectDao, BranchDao branc } public Optional create(UUID projectId, UUID branchId, Commit commit) { + return create(projectId, branchId, commit, dao::persist); + } + + public Optional createNameResolved(UUID projectId, UUID branchId, Commit commit) { + return create(projectId, branchId, commit, dao::persistNameResolved); + } + + private Optional create(UUID projectId, UUID branchId, Commit commit, BiFunction> persister) { Project project = projectDao.findById(projectId) .orElseThrow(() -> new IllegalArgumentException("Project " + projectId + " not found")); commit.setOwningProject(project); @@ -57,7 +66,7 @@ public Optional create(UUID projectId, UUID branchId, Commit commit) { .orElseThrow(() -> new IllegalArgumentException("Branch " + branchId + " not found")) : Optional.ofNullable(project.getDefaultBranch()) .orElseThrow(() -> new IllegalStateException("Branch not specified and project does not have default branch")); - return dao.persist(commit, branch); + return persister.apply(commit, branch); } public List getByProjectId(UUID projectId, UUID after, UUID before, int maxResults) { diff --git a/app/services/ElementService.java b/app/services/ElementService.java index 50f7fba2..137a6d60 100644 --- a/app/services/ElementService.java +++ b/app/services/ElementService.java @@ -24,7 +24,6 @@ import dao.CommitDao; import dao.ElementDao; import dao.ProjectDao; -import dao.QueryDao; import org.omg.sysml.metamodel.Element; import javax.annotation.Nullable; @@ -52,7 +51,7 @@ public Optional create(Element element) { return element.getIdentifier() != null ? dao.update(element) : dao.persist(element); } - public Optional getByCommitIdAndId(UUID commitId, UUID elementId) { + public Optional getElementByCommitIdElementId(UUID commitId, UUID elementId) { return commitDao.findById(commitId) .flatMap(m -> dao.findByCommitAndId(m, elementId)); } @@ -64,7 +63,7 @@ public List getElementsByProjectIdCommitId(UUID projectId, UUID commitI .orElse(Collections.emptyList()); } - public Optional getElementsByProjectIdCommitIdElementId(UUID projectId, UUID commitId, UUID elementId) { + public Optional getElementByProjectIdCommitIdElementId(UUID projectId, UUID commitId, UUID elementId) { return projectDao.findById(projectId) .flatMap(project -> commitDao.findByProjectAndId(project, commitId)) .flatMap(commit -> dao.findByCommitAndId(commit, elementId)); @@ -76,4 +75,10 @@ public List getRootsByProjectIdCommitId(UUID projectId, UUID commitId, .map(commit -> dao.findRootsByCommit(commit, after, before, maxResults)) .orElse(Collections.emptyList()); } + + public Optional getElementByProjectIdCommitIdQualifiedName(UUID projectId, UUID commitId, String qualifiedName) { + return projectDao.findById(projectId) + .flatMap(project -> commitDao.findByProjectAndId(project, commitId)) + .flatMap(commit -> dao.findByCommitAndQualifiedName(commit, qualifiedName)); + } } diff --git a/conf/META-INF/persistence.xml b/conf/META-INF/persistence.xml index ff4c905b..3707bd7b 100644 --- a/conf/META-INF/persistence.xml +++ b/conf/META-INF/persistence.xml @@ -11,7 +11,8 @@ org.omg.sysml.data.impl.ProjectUsageImpl org.omg.sysml.internal.impl - org.omg.sysml.internal.impl.CommitIndexImpl + org.omg.sysml.internal.impl.CommitDataVersionIndexImpl + org.omg.sysml.internal.impl.CommitNamedElementIndexImpl org.omg.sysml.lifecycle.impl org.omg.sysml.lifecycle.impl.BranchImpl @@ -201,7 +202,7 @@ - + diff --git a/conf/routes b/conf/routes index 13a39941..b0026477 100644 --- a/conf/routes +++ b/conf/routes @@ -47,6 +47,10 @@ GET /projects/:projectId/queries/:queryId/results GET /projects/:projectId/query-results controllers.QueryController.getQueryResultsByProjectIdQuery(projectId : java.util.UUID, commitId : java.util.Optional[java.util.UUID], request : Request) POST /projects/:projectId/query-results controllers.QueryController.getQueryResultsByProjectIdQuery(projectId : java.util.UUID, commitId : java.util.Optional[java.util.UUID], request : Request) +# Extension endpoints +POST /x/named/projects/:projectId/commits controllers.CommitController.postCommitByProjectNameResolved(projectId : java.util.UUID, branchId : java.util.Optional[java.util.UUID], request : Request) +GET /x/named/projects/:projectId/commits/:commitId/elements/:qualifiedName controllers.ElementController.getElementByProjectIdCommitIdQualifiedName(projectId : java.util.UUID, commitId : java.util.UUID, qualifiedName : String, request : Request) + # Map static resources from the /public folder to the /assets URL path GET /assets/*file controllers.Assets.versioned(path="/public", file: Asset) diff --git a/generated/org/omg/sysml/internal/impl/CommitIndexImpl_.java b/generated/org/omg/sysml/internal/impl/CommitDataVersionIndexImpl_.java similarity index 54% rename from generated/org/omg/sysml/internal/impl/CommitIndexImpl_.java rename to generated/org/omg/sysml/internal/impl/CommitDataVersionIndexImpl_.java index d347fbf8..81f12b77 100644 --- a/generated/org/omg/sysml/internal/impl/CommitIndexImpl_.java +++ b/generated/org/omg/sysml/internal/impl/CommitDataVersionIndexImpl_.java @@ -9,16 +9,16 @@ import org.omg.sysml.lifecycle.impl.DataVersionImpl; @Generated(value = "org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor") -@StaticMetamodel(CommitIndexImpl.class) -public abstract class CommitIndexImpl_ { +@StaticMetamodel(CommitDataVersionIndexImpl.class) +public abstract class CommitDataVersionIndexImpl_ { - public static volatile SingularAttribute commit; - public static volatile SingularAttribute id; - public static volatile SetAttribute workingDataVersions; + public static volatile SingularAttribute commit; + public static volatile SetAttribute workingDataVersion; + public static volatile SingularAttribute id; public static final String COMMIT = "commit"; + public static final String WORKING_DATA_VERSION = "workingDataVersion"; public static final String ID = "id"; - public static final String WORKING_DATA_VERSIONS = "workingDataVersions"; } diff --git a/generated/org/omg/sysml/internal/impl/CommitNamedElementIndexImpl_.java b/generated/org/omg/sysml/internal/impl/CommitNamedElementIndexImpl_.java new file mode 100644 index 00000000..459bc9a9 --- /dev/null +++ b/generated/org/omg/sysml/internal/impl/CommitNamedElementIndexImpl_.java @@ -0,0 +1,24 @@ +package org.omg.sysml.internal.impl; + +import java.util.UUID; +import javax.annotation.processing.Generated; +import javax.persistence.metamodel.MapAttribute; +import javax.persistence.metamodel.SingularAttribute; +import javax.persistence.metamodel.StaticMetamodel; +import org.omg.sysml.lifecycle.impl.CommitImpl; +import org.omg.sysml.metamodel.Element; + +@Generated(value = "org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor") +@StaticMetamodel(CommitNamedElementIndexImpl.class) +public abstract class CommitNamedElementIndexImpl_ { + + public static volatile MapAttribute workingNamedElement; + public static volatile SingularAttribute commit; + public static volatile SingularAttribute id; + + public static final String WORKING_NAMED_ELEMENT = "workingNamedElement"; + public static final String COMMIT = "commit"; + public static final String ID = "id"; + +} + diff --git a/public/swagger/openapi.yaml b/public/swagger/openapi.yaml index 988ca981..80035d22 100644 --- a/public/swagger/openapi.yaml +++ b/public/swagger/openapi.yaml @@ -11,6 +11,7 @@ tags: - name: Element - name: Relationship - name: Query + - name: Extension paths: /projects: @@ -987,6 +988,87 @@ paths: $ref: '#/responses/InternalServerError' default: $ref: '#/responses/Default' + /x/named/projects/{projectId}/commits: + parameters: + - name: projectId + in: path + description: ID of the project + type: string + format: uuid + required: true + post: + tags: + - Extension + operationId: postCommitByProjectNameResolved + summary: Create commit by project, resolving references by qualified name + consumes: + - application/json + produces: + - application/json + - application/ld+json + parameters: + - name: body + in: body + required: true + schema: + $ref: '#/definitions/Commit' + - name: branchId + in: query + description: ID of the branch - project's default branch if unspecified + type: string + format: uuid + required: false + responses: + 201: + description: Created + schema: + $ref: '#/definitions/Commit' + 415: + $ref: '#/responses/BadContentType' + 500: + $ref: '#/responses/InternalServerError' + default: + $ref: '#/responses/Default' + /x/named/projects/{projectId}/commits/{commitId}/elements/{qualifiedName}: + parameters: + - name: projectId + in: path + description: ID of the project + type: string + format: uuid + required: true + - name: commitId + in: path + description: ID of the commit + type: string + format: uuid + required: true + - name: qualifiedName + in: path + description: Qualified name of the element + type: string + required: true + get: + tags: + - Extension + operationId: getElementByProjectCommitQualifiedName + summary: Get element by project, commit and qualified name + produces: + - application/json + - application/ld+json + responses: + 200: + description: Ok + schema: + $ref: '#/definitions/Element' + 404: + $ref: '#/responses/NotFound' + 415: + $ref: '#/responses/BadContentType' + 500: + $ref: '#/responses/InternalServerError' + default: + $ref: '#/responses/Default' definitions: Project: type: object From d01165b793544eabcfdd919f68559888812cb856 Mon Sep 17 00:00:00 2001 From: Ivan Gomes Date: Sun, 27 Feb 2022 20:13:20 -0500 Subject: [PATCH 2/3] ST5AS-188 Update to 2022-02 metamodel baseline --- app/dao/impl/jpa/JpaDataDao.java | 1 - .../sysml/lifecycle/impl/package-info.java | 5 +- ...Expression.java => CollectExpression.java} | 2 +- .../metamodel/FeatureChainExpression.java | 32 + ...tExpression.java => SelectExpression.java} | 2 +- ...onImpl.java => CollectExpressionImpl.java} | 152 +- .../impl/FeatureChainExpressionImpl.java | 1629 +++++++++++++++++ ...ionImpl.java => SelectExpressionImpl.java} | 152 +- .../sysml/metamodel/impl/package-info.java | 65 +- conf/META-INF/persistence.xml | 7 +- .../impl/CollectExpressionImpl_.java | 152 ++ .../impl/FeatureChainExpressionImpl_.java | 152 ++ .../impl/PathSelectExpressionImpl_.java | 152 -- .../impl/PathStepExpressionImpl_.java | 152 -- .../metamodel/impl/SelectExpressionImpl_.java | 152 ++ ...ession.jsonld => CollectExpression.jsonld} | 0 .../metamodel/FeatureChainExpression.jsonld | 79 + ...ression.jsonld => SelectExpression.jsonld} | 0 18 files changed, 2396 insertions(+), 490 deletions(-) rename app/org/omg/sysml/metamodel/{PathStepExpression.java => CollectExpression.java} (93%) create mode 100644 app/org/omg/sysml/metamodel/FeatureChainExpression.java rename app/org/omg/sysml/metamodel/{PathSelectExpression.java => SelectExpression.java} (93%) rename app/org/omg/sysml/metamodel/impl/{PathStepExpressionImpl.java => CollectExpressionImpl.java} (91%) create mode 100644 app/org/omg/sysml/metamodel/impl/FeatureChainExpressionImpl.java rename app/org/omg/sysml/metamodel/impl/{PathSelectExpressionImpl.java => SelectExpressionImpl.java} (91%) create mode 100644 generated/org/omg/sysml/metamodel/impl/CollectExpressionImpl_.java create mode 100644 generated/org/omg/sysml/metamodel/impl/FeatureChainExpressionImpl_.java delete mode 100644 generated/org/omg/sysml/metamodel/impl/PathSelectExpressionImpl_.java delete mode 100644 generated/org/omg/sysml/metamodel/impl/PathStepExpressionImpl_.java create mode 100644 generated/org/omg/sysml/metamodel/impl/SelectExpressionImpl_.java rename public/jsonld/metamodel/{PathSelectExpression.jsonld => CollectExpression.jsonld} (100%) create mode 100644 public/jsonld/metamodel/FeatureChainExpression.jsonld rename public/jsonld/metamodel/{PathStepExpression.jsonld => SelectExpression.jsonld} (100%) diff --git a/app/dao/impl/jpa/JpaDataDao.java b/app/dao/impl/jpa/JpaDataDao.java index feba6ba2..78ba4c13 100644 --- a/app/dao/impl/jpa/JpaDataDao.java +++ b/app/dao/impl/jpa/JpaDataDao.java @@ -31,7 +31,6 @@ import org.omg.sysml.internal.CommitDataVersionIndex; import org.omg.sysml.internal.impl.CommitDataVersionIndexImpl; import org.omg.sysml.internal.impl.CommitDataVersionIndexImpl_; -import org.omg.sysml.internal.impl.CommitIndexImpl_; import org.omg.sysml.lifecycle.Commit; import org.omg.sysml.lifecycle.Data; import org.omg.sysml.lifecycle.DataIdentity; diff --git a/app/org/omg/sysml/lifecycle/impl/package-info.java b/app/org/omg/sysml/lifecycle/impl/package-info.java index 1d856a97..8374b243 100644 --- a/app/org/omg/sysml/lifecycle/impl/package-info.java +++ b/app/org/omg/sysml/lifecycle/impl/package-info.java @@ -54,6 +54,7 @@ @MetaValue(value = "CaseUsage", targetEntity = CaseUsageImpl.class), @MetaValue(value = "Class", targetEntity = ClassImpl.class), @MetaValue(value = "Classifier", targetEntity = ClassifierImpl.class), + @MetaValue(value = "CollectExpression", targetEntity = CollectExpressionImpl.class), @MetaValue(value = "Comment", targetEntity = CommentImpl.class), @MetaValue(value = "ConcernDefinition", targetEntity = ConcernDefinitionImpl.class), @MetaValue(value = "ConcernUsage", targetEntity = ConcernUsageImpl.class), @@ -83,6 +84,7 @@ @MetaValue(value = "Expose", targetEntity = ExposeImpl.class), @MetaValue(value = "Expression", targetEntity = ExpressionImpl.class), @MetaValue(value = "Feature", targetEntity = FeatureImpl.class), + @MetaValue(value = "FeatureChainExpression", targetEntity = FeatureChainExpressionImpl.class), @MetaValue(value = "FeatureChaining", targetEntity = FeatureChainingImpl.class), @MetaValue(value = "FeatureMembership", targetEntity = FeatureMembershipImpl.class), @MetaValue(value = "FeatureReferenceExpression", targetEntity = FeatureReferenceExpressionImpl.class), @@ -132,8 +134,6 @@ @MetaValue(value = "ParameterMembership", targetEntity = ParameterMembershipImpl.class), @MetaValue(value = "PartDefinition", targetEntity = PartDefinitionImpl.class), @MetaValue(value = "PartUsage", targetEntity = PartUsageImpl.class), - @MetaValue(value = "PathSelectExpression", targetEntity = PathSelectExpressionImpl.class), - @MetaValue(value = "PathStepExpression", targetEntity = PathStepExpressionImpl.class), @MetaValue(value = "PerformActionUsage", targetEntity = PerformActionUsageImpl.class), @MetaValue(value = "PortConjugation", targetEntity = PortConjugationImpl.class), @MetaValue(value = "PortDefinition", targetEntity = PortDefinitionImpl.class), @@ -152,6 +152,7 @@ @MetaValue(value = "ResultExpressionMembership", targetEntity = ResultExpressionMembershipImpl.class), @MetaValue(value = "ReturnParameterMembership", targetEntity = ReturnParameterMembershipImpl.class), @MetaValue(value = "SatisfyRequirementUsage", targetEntity = SatisfyRequirementUsageImpl.class), + @MetaValue(value = "SelectExpression", targetEntity = SelectExpressionImpl.class), @MetaValue(value = "SendActionUsage", targetEntity = SendActionUsageImpl.class), @MetaValue(value = "SourceEnd", targetEntity = SourceEndImpl.class), @MetaValue(value = "Specialization", targetEntity = SpecializationImpl.class), diff --git a/app/org/omg/sysml/metamodel/PathStepExpression.java b/app/org/omg/sysml/metamodel/CollectExpression.java similarity index 93% rename from app/org/omg/sysml/metamodel/PathStepExpression.java rename to app/org/omg/sysml/metamodel/CollectExpression.java index 624a51cc..a7604c6e 100644 --- a/app/org/omg/sysml/metamodel/PathStepExpression.java +++ b/app/org/omg/sysml/metamodel/CollectExpression.java @@ -25,6 +25,6 @@ import java.util.List; import java.util.Set; -public interface PathStepExpression extends OperatorExpression, SysMLType { +public interface CollectExpression extends OperatorExpression, SysMLType { String getOperator(); } \ No newline at end of file diff --git a/app/org/omg/sysml/metamodel/FeatureChainExpression.java b/app/org/omg/sysml/metamodel/FeatureChainExpression.java new file mode 100644 index 00000000..18662bb6 --- /dev/null +++ b/app/org/omg/sysml/metamodel/FeatureChainExpression.java @@ -0,0 +1,32 @@ +/* + * SysML v2 REST/HTTP Pilot Implementation + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + * + * @license LGPL-3.0-or-later + */ + +package org.omg.sysml.metamodel; + +import java.util.Collection; +import java.util.List; +import java.util.Set; + +public interface FeatureChainExpression extends OperatorExpression, SysMLType { + String getOperator(); + + Feature getTargetFeature(); +} \ No newline at end of file diff --git a/app/org/omg/sysml/metamodel/PathSelectExpression.java b/app/org/omg/sysml/metamodel/SelectExpression.java similarity index 93% rename from app/org/omg/sysml/metamodel/PathSelectExpression.java rename to app/org/omg/sysml/metamodel/SelectExpression.java index c27fe70e..0e62089c 100644 --- a/app/org/omg/sysml/metamodel/PathSelectExpression.java +++ b/app/org/omg/sysml/metamodel/SelectExpression.java @@ -25,6 +25,6 @@ import java.util.List; import java.util.Set; -public interface PathSelectExpression extends OperatorExpression, SysMLType { +public interface SelectExpression extends OperatorExpression, SysMLType { String getOperator(); } \ No newline at end of file diff --git a/app/org/omg/sysml/metamodel/impl/PathStepExpressionImpl.java b/app/org/omg/sysml/metamodel/impl/CollectExpressionImpl.java similarity index 91% rename from app/org/omg/sysml/metamodel/impl/PathStepExpressionImpl.java rename to app/org/omg/sysml/metamodel/impl/CollectExpressionImpl.java index d8372d9d..4d41e591 100644 --- a/app/org/omg/sysml/metamodel/impl/PathStepExpressionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/CollectExpressionImpl.java @@ -61,14 +61,14 @@ import java.util.Set; import java.util.HashSet; -@Entity(name = "PathStepExpressionImpl") -@SecondaryTable(name = "PathStepExpression") -@org.hibernate.annotations.Table(appliesTo = "PathStepExpression", fetch = FetchMode.SELECT, optional = false) -// @info.archinnov.achilles.annotations.Table(table = "PathStepExpression") -@DiscriminatorValue(value = "PathStepExpression") -@JsonTypeName(value = "PathStepExpression") +@Entity(name = "CollectExpressionImpl") +@SecondaryTable(name = "CollectExpression") +@org.hibernate.annotations.Table(appliesTo = "CollectExpression", fetch = FetchMode.SELECT, optional = false) +// @info.archinnov.achilles.annotations.Table(table = "CollectExpression") +@DiscriminatorValue(value = "CollectExpression") +@JsonTypeName(value = "CollectExpression") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) -public class PathStepExpressionImpl extends SysMLTypeImpl implements PathStepExpression { +public class CollectExpressionImpl extends SysMLTypeImpl implements CollectExpression { // @info.archinnov.achilles.annotations.Column("aliasId") private List aliasId; @@ -76,8 +76,8 @@ public class PathStepExpressionImpl extends SysMLTypeImpl implements PathStepExp @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "PathStepExpression_aliasId", - joinColumns = @JoinColumn(name = "PathStepExpressionId")) + @CollectionTable(name = "CollectExpression_aliasId", + joinColumns = @JoinColumn(name = "CollectExpressionId")) public List getAliasId() { if (aliasId == null) { aliasId = new ArrayList<>(); @@ -100,7 +100,7 @@ public void setAliasId(List aliasId) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_argument", + @JoinTable(name = "CollectExpression_argument", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getArgument() { @@ -126,7 +126,7 @@ public void setArgument(List argument) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_behavior", + @JoinTable(name = "CollectExpression_behavior", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getBehavior() { @@ -152,7 +152,7 @@ public void setBehavior(List behavior) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_chainingFeature", + @JoinTable(name = "CollectExpression_chainingFeature", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getChainingFeature() { @@ -178,7 +178,7 @@ public void setChainingFeature(List chainingFeature) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_directedFeature", + @JoinTable(name = "CollectExpression_directedFeature", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getDirectedFeature() { @@ -202,7 +202,7 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @javax.persistence.Enumerated(EnumType.STRING) - @javax.persistence.Column(name = "direction", table = "PathStepExpression") + @javax.persistence.Column(name = "direction", table = "CollectExpression") public FeatureDirectionKind getDirection() { return direction; } @@ -222,7 +222,7 @@ public void setDirection(FeatureDirectionKind direction) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_documentation", + @JoinTable(name = "CollectExpression_documentation", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getDocumentation() { @@ -248,7 +248,7 @@ public void setDocumentation(List documentation) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "CommentMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_documentationComment", + @JoinTable(name = "CollectExpression_documentationComment", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getDocumentationComment() { @@ -274,7 +274,7 @@ public void setDocumentationComment(List documentationComment) { @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") // @javax.persistence.Transient - @javax.persistence.Column(name = "effectiveName", table = "PathStepExpression") + @javax.persistence.Column(name = "effectiveName", table = "CollectExpression") public String getEffectiveName() { return effectiveName; } @@ -294,7 +294,7 @@ public void setEffectiveName(String effectiveName) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_endFeature", + @JoinTable(name = "CollectExpression_endFeature", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getEndFeature() { @@ -320,7 +320,7 @@ public void setEndFeature(List endFeature) { @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "PathStepExpression") + @JoinColumn(name = "endOwningTypeId", table = "CollectExpression") public Type getEndOwningType() { return endOwningType; } @@ -341,7 +341,7 @@ public void setEndOwningType(Type endOwningType) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_feature", + @JoinTable(name = "CollectExpression_feature", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getFeature() { @@ -367,7 +367,7 @@ public void setFeature(List feature) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_featureMembership", + @JoinTable(name = "CollectExpression_featureMembership", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getFeatureMembership() { @@ -393,7 +393,7 @@ public void setFeatureMembership(List featureMembership) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_featuringType", + @JoinTable(name = "CollectExpression_featuringType", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getFeaturingType() { @@ -419,7 +419,7 @@ public void setFeaturingType(List featuringType) { @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "PathStepExpression") + @JoinColumn(name = "functionId", table = "CollectExpression") public Function getFunction() { return function; } @@ -438,7 +438,7 @@ public void setFunction(Function function) { @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "PathStepExpression") + @javax.persistence.Column(name = "humanId", table = "CollectExpression") public String getHumanId() { return humanId; } @@ -454,7 +454,7 @@ public void setHumanId(String humanId) { private java.util.UUID identifier; @JsonGetter - @javax.persistence.Column(name = "identifier", table = "PathStepExpression") + @javax.persistence.Column(name = "identifier", table = "CollectExpression") public java.util.UUID getIdentifier() { return identifier; } @@ -474,7 +474,7 @@ public void setIdentifier(java.util.UUID identifier) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_importedMembership", + @JoinTable(name = "CollectExpression_importedMembership", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getImportedMembership() { @@ -500,7 +500,7 @@ public void setImportedMembership(List importedMembership) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_inheritedFeature", + @JoinTable(name = "CollectExpression_inheritedFeature", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getInheritedFeature() { @@ -526,7 +526,7 @@ public void setInheritedFeature(List inheritedFeature) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_inheritedMembership", + @JoinTable(name = "CollectExpression_inheritedMembership", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getInheritedMembership() { @@ -552,7 +552,7 @@ public void setInheritedMembership(List inheritedMembership) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_input", + @JoinTable(name = "CollectExpression_input", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getInput() { @@ -574,7 +574,7 @@ public void setInput(List input) { private Boolean isAbstract; @JsonGetter - @javax.persistence.Column(name = "isAbstract", table = "PathStepExpression") + @javax.persistence.Column(name = "isAbstract", table = "CollectExpression") public Boolean getIsAbstract() { return isAbstract; } @@ -590,7 +590,7 @@ public void setIsAbstract(Boolean isAbstract) { private Boolean isComposite; @JsonGetter - @javax.persistence.Column(name = "isComposite", table = "PathStepExpression") + @javax.persistence.Column(name = "isComposite", table = "CollectExpression") public Boolean getIsComposite() { return isComposite; } @@ -608,7 +608,7 @@ public void setIsComposite(Boolean isComposite) { @JsonGetter // @javax.persistence.Transient - @javax.persistence.Column(name = "isConjugated", table = "PathStepExpression") + @javax.persistence.Column(name = "isConjugated", table = "CollectExpression") public Boolean getIsConjugated() { return isConjugated; } @@ -624,7 +624,7 @@ public void setIsConjugated(Boolean isConjugated) { private Boolean isDerived; @JsonGetter - @javax.persistence.Column(name = "isDerived", table = "PathStepExpression") + @javax.persistence.Column(name = "isDerived", table = "CollectExpression") public Boolean getIsDerived() { return isDerived; } @@ -640,7 +640,7 @@ public void setIsDerived(Boolean isDerived) { private Boolean isEnd; @JsonGetter - @javax.persistence.Column(name = "isEnd", table = "PathStepExpression") + @javax.persistence.Column(name = "isEnd", table = "CollectExpression") public Boolean getIsEnd() { return isEnd; } @@ -658,7 +658,7 @@ public void setIsEnd(Boolean isEnd) { @JsonGetter // @javax.persistence.Transient - @javax.persistence.Column(name = "isModelLevelEvaluable", table = "PathStepExpression") + @javax.persistence.Column(name = "isModelLevelEvaluable", table = "CollectExpression") public Boolean getIsModelLevelEvaluable() { return isModelLevelEvaluable; } @@ -676,7 +676,7 @@ public void setIsModelLevelEvaluable(Boolean isModelLevelEvaluable) { @JsonGetter // @javax.persistence.Transient - @javax.persistence.Column(name = "isNonunique", table = "PathStepExpression") + @javax.persistence.Column(name = "isNonunique", table = "CollectExpression") public Boolean getIsNonunique() { return isNonunique; } @@ -692,7 +692,7 @@ public void setIsNonunique(Boolean isNonunique) { private Boolean isOrdered; @JsonGetter - @javax.persistence.Column(name = "isOrdered", table = "PathStepExpression") + @javax.persistence.Column(name = "isOrdered", table = "CollectExpression") public Boolean getIsOrdered() { return isOrdered; } @@ -708,7 +708,7 @@ public void setIsOrdered(Boolean isOrdered) { private Boolean isPortion; @JsonGetter - @javax.persistence.Column(name = "isPortion", table = "PathStepExpression") + @javax.persistence.Column(name = "isPortion", table = "CollectExpression") public Boolean getIsPortion() { return isPortion; } @@ -724,7 +724,7 @@ public void setIsPortion(Boolean isPortion) { private Boolean isReadOnly; @JsonGetter - @javax.persistence.Column(name = "isReadOnly", table = "PathStepExpression") + @javax.persistence.Column(name = "isReadOnly", table = "CollectExpression") public Boolean getIsReadOnly() { return isReadOnly; } @@ -740,7 +740,7 @@ public void setIsReadOnly(Boolean isReadOnly) { private Boolean isSufficient; @JsonGetter - @javax.persistence.Column(name = "isSufficient", table = "PathStepExpression") + @javax.persistence.Column(name = "isSufficient", table = "CollectExpression") public Boolean getIsSufficient() { return isSufficient; } @@ -756,7 +756,7 @@ public void setIsSufficient(Boolean isSufficient) { private Boolean isUnique; @JsonGetter - @javax.persistence.Column(name = "isUnique", table = "PathStepExpression") + @javax.persistence.Column(name = "isUnique", table = "CollectExpression") public Boolean getIsUnique() { return isUnique; } @@ -776,7 +776,7 @@ public void setIsUnique(Boolean isUnique) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_member", + @JoinTable(name = "CollectExpression_member", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getMember() { @@ -802,7 +802,7 @@ public void setMember(List member) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_membership", + @JoinTable(name = "CollectExpression_membership", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getMembership() { @@ -828,7 +828,7 @@ public void setMembership(List membership) { @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "PathStepExpression") + @JoinColumn(name = "multiplicityId", table = "CollectExpression") public Multiplicity getMultiplicity() { return multiplicity; } @@ -849,7 +849,7 @@ public void setMultiplicity(Multiplicity multiplicity) { @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") // @javax.persistence.Transient - @javax.persistence.Column(name = "name", table = "PathStepExpression") + @javax.persistence.Column(name = "name", table = "CollectExpression") public String getName() { return name; } @@ -869,7 +869,7 @@ public void setName(String name) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_operand", + @JoinTable(name = "CollectExpression_operand", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOperand() { @@ -893,7 +893,7 @@ public void setOperand(List operand) { @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "operator", table = "PathStepExpression") + @javax.persistence.Column(name = "operator", table = "CollectExpression") public String getOperator() { return operator; } @@ -913,7 +913,7 @@ public void setOperator(String operator) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_output", + @JoinTable(name = "CollectExpression_output", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOutput() { @@ -939,7 +939,7 @@ public void setOutput(List output) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_ownedAnnotation", + @JoinTable(name = "CollectExpression_ownedAnnotation", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedAnnotation() { @@ -965,7 +965,7 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "PathStepExpression") + @JoinColumn(name = "ownedConjugatorId", table = "CollectExpression") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -986,7 +986,7 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_ownedDisjoining", + @JoinTable(name = "CollectExpression_ownedDisjoining", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public Collection getOwnedDisjoining() { @@ -1012,7 +1012,7 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_ownedElement", + @JoinTable(name = "CollectExpression_ownedElement", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedElement() { @@ -1038,7 +1038,7 @@ public void setOwnedElement(List ownedElement) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_ownedEndFeature", + @JoinTable(name = "CollectExpression_ownedEndFeature", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedEndFeature() { @@ -1064,7 +1064,7 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_ownedFeature", + @JoinTable(name = "CollectExpression_ownedFeature", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedFeature() { @@ -1090,7 +1090,7 @@ public void setOwnedFeature(List ownedFeature) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_ownedFeatureChaining", + @JoinTable(name = "CollectExpression_ownedFeatureChaining", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedFeatureChaining() { @@ -1116,7 +1116,7 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_ownedFeatureMembership", + @JoinTable(name = "CollectExpression_ownedFeatureMembership", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedFeatureMembership() { @@ -1142,7 +1142,7 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_ownedImport", + @JoinTable(name = "CollectExpression_ownedImport", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedImport() { @@ -1168,7 +1168,7 @@ public void setOwnedImport(List ownedImport) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_ownedMember", + @JoinTable(name = "CollectExpression_ownedMember", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedMember() { @@ -1194,7 +1194,7 @@ public void setOwnedMember(List ownedMember) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_ownedMembership", + @JoinTable(name = "CollectExpression_ownedMembership", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedMembership() { @@ -1220,7 +1220,7 @@ public void setOwnedMembership(List ownedMembership) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_ownedRedefinition", + @JoinTable(name = "CollectExpression_ownedRedefinition", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public Collection getOwnedRedefinition() { @@ -1244,7 +1244,7 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_ownedRelationship", + @JoinTable(name = "CollectExpression_ownedRelationship", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedRelationship() { @@ -1270,7 +1270,7 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_ownedSpecialization", + @JoinTable(name = "CollectExpression_ownedSpecialization", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedSpecialization() { @@ -1296,7 +1296,7 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_ownedSubsetting", + @JoinTable(name = "CollectExpression_ownedSubsetting", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public Collection getOwnedSubsetting() { @@ -1322,7 +1322,7 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_ownedTextualRepresentation", + @JoinTable(name = "CollectExpression_ownedTextualRepresentation", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public Collection getOwnedTextualRepresentation() { @@ -1348,7 +1348,7 @@ public void setOwnedTextualRepresentation(Collection owne @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_ownedTypeFeaturing", + @JoinTable(name = "CollectExpression_ownedTypeFeaturing", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedTypeFeaturing() { @@ -1374,7 +1374,7 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_ownedTyping", + @JoinTable(name = "CollectExpression_ownedTyping", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedTyping() { @@ -1400,7 +1400,7 @@ public void setOwnedTyping(List ownedTyping) { @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "PathStepExpression") + @JoinColumn(name = "ownerId", table = "CollectExpression") public Element getOwner() { return owner; } @@ -1419,7 +1419,7 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "PathStepExpression") + @JoinColumn(name = "owningFeatureMembershipId", table = "CollectExpression") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1438,7 +1438,7 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership @JsonGetter @JsonSerialize(using = DataSerializer.class) @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "PathStepExpression") + @JoinColumn(name = "owningMembershipId", table = "CollectExpression") public Membership getOwningMembership() { return owningMembership; } @@ -1459,7 +1459,7 @@ public void setOwningMembership(Membership owningMembership) { @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "PathStepExpression") + @JoinColumn(name = "owningNamespaceId", table = "CollectExpression") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1478,7 +1478,7 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "PathStepExpression") + @JoinColumn(name = "owningRelationshipId", table = "CollectExpression") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1499,7 +1499,7 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "PathStepExpression") + @JoinColumn(name = "owningTypeId", table = "CollectExpression") public Type getOwningType() { return owningType; } @@ -1520,7 +1520,7 @@ public void setOwningType(Type owningType) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_parameter", + @JoinTable(name = "CollectExpression_parameter", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getParameter() { @@ -1546,7 +1546,7 @@ public void setParameter(List parameter) { @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") // @javax.persistence.Transient - @javax.persistence.Column(name = "qualifiedName", table = "PathStepExpression") + @javax.persistence.Column(name = "qualifiedName", table = "CollectExpression") public String getQualifiedName() { return qualifiedName; } @@ -1566,7 +1566,7 @@ public void setQualifiedName(String qualifiedName) { @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "PathStepExpression") + @JoinColumn(name = "resultId", table = "CollectExpression") public Feature getResult() { return result; } @@ -1587,7 +1587,7 @@ public void setResult(Feature result) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathStepExpression_type", + @JoinTable(name = "CollectExpression_type", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getType() { diff --git a/app/org/omg/sysml/metamodel/impl/FeatureChainExpressionImpl.java b/app/org/omg/sysml/metamodel/impl/FeatureChainExpressionImpl.java new file mode 100644 index 00000000..d8cba1fe --- /dev/null +++ b/app/org/omg/sysml/metamodel/impl/FeatureChainExpressionImpl.java @@ -0,0 +1,1629 @@ +/* + * SysML v2 REST/HTTP Pilot Implementation + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this program. If not, see . + * + * @license LGPL-3.0-or-later + */ + +package org.omg.sysml.metamodel.impl; + +import org.omg.sysml.metamodel.*; + +import org.omg.sysml.metamodel.Package; +import org.omg.sysml.metamodel.Class; + +import jackson.DataSerializer; +import jackson.DataDeserializer; + +import com.fasterxml.jackson.annotation.*; +import com.fasterxml.jackson.databind.annotation.JsonSerialize; +import com.fasterxml.jackson.databind.annotation.JsonDeserialize; + +import org.hibernate.annotations.Any; +import org.hibernate.annotations.ManyToAny; +import org.hibernate.annotations.FetchMode; + +// import info.archinnov.achilles.annotations.UDT; + +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.EnumType; +import javax.persistence.ElementCollection; +import javax.persistence.Inheritance; +import javax.persistence.InheritanceType; +import javax.persistence.PrimaryKeyJoinColumn; +import javax.persistence.JoinColumn; +import javax.persistence.JoinTable; +import javax.persistence.Lob; +import javax.persistence.FetchType; +import javax.persistence.DiscriminatorValue; +import javax.persistence.Table; +import javax.persistence.SecondaryTable; +import javax.persistence.CollectionTable; + +import java.util.Collection; +import java.util.ArrayList; +import java.util.List; +import java.util.Set; +import java.util.HashSet; + +@Entity(name = "FeatureChainExpressionImpl") +@SecondaryTable(name = "FeatureChainExpression") +@org.hibernate.annotations.Table(appliesTo = "FeatureChainExpression", fetch = FetchMode.SELECT, optional = false) +// @info.archinnov.achilles.annotations.Table(table = "FeatureChainExpression") +@DiscriminatorValue(value = "FeatureChainExpression") +@JsonTypeName(value = "FeatureChainExpression") +@JsonTypeInfo(use = JsonTypeInfo.Id.NAME) +public class FeatureChainExpressionImpl extends SysMLTypeImpl implements FeatureChainExpression { + // @info.archinnov.achilles.annotations.Column("aliasId") + private List aliasId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @ElementCollection(targetClass = String.class) + @CollectionTable(name = "FeatureChainExpression_aliasId", + joinColumns = @JoinColumn(name = "FeatureChainExpressionId")) + public List getAliasId() { + if (aliasId == null) { + aliasId = new ArrayList<>(); + } + return aliasId; + } + + @JsonSetter + public void setAliasId(List aliasId) { + this.aliasId = aliasId; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("argument") + private List argument; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_argument", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getArgument() { + if (argument == null) { + argument = new ArrayList<>(); + } + return argument; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = ExpressionImpl.class) + public void setArgument(List argument) { + this.argument = argument; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("behavior") + private List behavior; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_behavior", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getBehavior() { + if (behavior == null) { + behavior = new ArrayList<>(); + } + return behavior; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = BehaviorImpl.class) + public void setBehavior(List behavior) { + this.behavior = behavior; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("chainingFeature") + private List chainingFeature; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_chainingFeature", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getChainingFeature() { + if (chainingFeature == null) { + chainingFeature = new ArrayList<>(); + } + return chainingFeature; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = FeatureImpl.class) + public void setChainingFeature(List chainingFeature) { + this.chainingFeature = chainingFeature; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("directedFeature") + private List directedFeature; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_directedFeature", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getDirectedFeature() { + if (directedFeature == null) { + directedFeature = new ArrayList<>(); + } + return directedFeature; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = FeatureImpl.class) + public void setDirectedFeature(List directedFeature) { + this.directedFeature = directedFeature; + } + + + + // @info.archinnov.achilles.annotations.Column("direction") + // @info.archinnov.achilles.annotations.Enumerated(info.archinnov.achilles.annotations.Enumerated.Encoding.NAME) + private FeatureDirectionKind direction; + + @JsonGetter + @javax.persistence.Enumerated(EnumType.STRING) + @javax.persistence.Column(name = "direction", table = "FeatureChainExpression") + public FeatureDirectionKind getDirection() { + return direction; + } + + @JsonSetter + public void setDirection(FeatureDirectionKind direction) { + this.direction = direction; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("documentation") + private List documentation; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_documentation", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getDocumentation() { + if (documentation == null) { + documentation = new ArrayList<>(); + } + return documentation; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = DocumentationImpl.class) + public void setDocumentation(List documentation) { + this.documentation = documentation; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("documentationComment") + private List documentationComment; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "CommentMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_documentationComment", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getDocumentationComment() { + if (documentationComment == null) { + documentationComment = new ArrayList<>(); + } + return documentationComment; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = CommentImpl.class) + public void setDocumentationComment(List documentationComment) { + this.documentationComment = documentationComment; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("effectiveName") + private String effectiveName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "effectiveName", table = "FeatureChainExpression") + public String getEffectiveName() { + return effectiveName; + } + + @JsonSetter + public void setEffectiveName(String effectiveName) { + this.effectiveName = effectiveName; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("endFeature") + private List endFeature; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_endFeature", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getEndFeature() { + if (endFeature == null) { + endFeature = new ArrayList<>(); + } + return endFeature; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = FeatureImpl.class) + public void setEndFeature(List endFeature) { + this.endFeature = endFeature; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("endOwningType") + private Type endOwningType; + + @JsonGetter + @JsonSerialize(using = DataSerializer.class) + // @javax.persistence.Transient + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningTypeId", table = "FeatureChainExpression") + public Type getEndOwningType() { + return endOwningType; + } + + @JsonSetter + @JsonDeserialize(using = DataDeserializer.class, as = TypeImpl.class) + public void setEndOwningType(Type endOwningType) { + this.endOwningType = endOwningType; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("feature") + private List feature; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_feature", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getFeature() { + if (feature == null) { + feature = new ArrayList<>(); + } + return feature; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = FeatureImpl.class) + public void setFeature(List feature) { + this.feature = feature; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("featureMembership") + private List featureMembership; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_featureMembership", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getFeatureMembership() { + if (featureMembership == null) { + featureMembership = new ArrayList<>(); + } + return featureMembership; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = FeatureMembershipImpl.class) + public void setFeatureMembership(List featureMembership) { + this.featureMembership = featureMembership; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("featuringType") + private List featuringType; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_featuringType", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getFeaturingType() { + if (featuringType == null) { + featuringType = new ArrayList<>(); + } + return featuringType; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = TypeImpl.class) + public void setFeaturingType(List featuringType) { + this.featuringType = featuringType; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("function") + private Function function; + + @JsonGetter + @JsonSerialize(using = DataSerializer.class) + // @javax.persistence.Transient + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) + @JoinColumn(name = "functionId", table = "FeatureChainExpression") + public Function getFunction() { + return function; + } + + @JsonSetter + @JsonDeserialize(using = DataDeserializer.class, as = FunctionImpl.class) + public void setFunction(Function function) { + this.function = function; + } + + + + // @info.archinnov.achilles.annotations.Column("humanId") + private String humanId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "humanId", table = "FeatureChainExpression") + public String getHumanId() { + return humanId; + } + + @JsonSetter + public void setHumanId(String humanId) { + this.humanId = humanId; + } + + + + // @info.archinnov.achilles.annotations.Column("identifier") + private java.util.UUID identifier; + + @JsonGetter + @javax.persistence.Column(name = "identifier", table = "FeatureChainExpression") + public java.util.UUID getIdentifier() { + return identifier; + } + + @JsonSetter + public void setIdentifier(java.util.UUID identifier) { + this.identifier = identifier; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("importedMembership") + private List importedMembership; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_importedMembership", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getImportedMembership() { + if (importedMembership == null) { + importedMembership = new ArrayList<>(); + } + return importedMembership; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = MembershipImpl.class) + public void setImportedMembership(List importedMembership) { + this.importedMembership = importedMembership; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("inheritedFeature") + private List inheritedFeature; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_inheritedFeature", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getInheritedFeature() { + if (inheritedFeature == null) { + inheritedFeature = new ArrayList<>(); + } + return inheritedFeature; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = FeatureImpl.class) + public void setInheritedFeature(List inheritedFeature) { + this.inheritedFeature = inheritedFeature; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("inheritedMembership") + private List inheritedMembership; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_inheritedMembership", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getInheritedMembership() { + if (inheritedMembership == null) { + inheritedMembership = new ArrayList<>(); + } + return inheritedMembership; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = MembershipImpl.class) + public void setInheritedMembership(List inheritedMembership) { + this.inheritedMembership = inheritedMembership; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("input") + private List input; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_input", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getInput() { + if (input == null) { + input = new ArrayList<>(); + } + return input; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = FeatureImpl.class) + public void setInput(List input) { + this.input = input; + } + + + + // @info.archinnov.achilles.annotations.Column("isAbstract") + private Boolean isAbstract; + + @JsonGetter + @javax.persistence.Column(name = "isAbstract", table = "FeatureChainExpression") + public Boolean getIsAbstract() { + return isAbstract; + } + + @JsonSetter + public void setIsAbstract(Boolean isAbstract) { + this.isAbstract = isAbstract; + } + + + + // @info.archinnov.achilles.annotations.Column("isComposite") + private Boolean isComposite; + + @JsonGetter + @javax.persistence.Column(name = "isComposite", table = "FeatureChainExpression") + public Boolean getIsComposite() { + return isComposite; + } + + @JsonSetter + public void setIsComposite(Boolean isComposite) { + this.isComposite = isComposite; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("isConjugated") + private Boolean isConjugated; + + @JsonGetter + // @javax.persistence.Transient + @javax.persistence.Column(name = "isConjugated", table = "FeatureChainExpression") + public Boolean getIsConjugated() { + return isConjugated; + } + + @JsonSetter + public void setIsConjugated(Boolean isConjugated) { + this.isConjugated = isConjugated; + } + + + + // @info.archinnov.achilles.annotations.Column("isDerived") + private Boolean isDerived; + + @JsonGetter + @javax.persistence.Column(name = "isDerived", table = "FeatureChainExpression") + public Boolean getIsDerived() { + return isDerived; + } + + @JsonSetter + public void setIsDerived(Boolean isDerived) { + this.isDerived = isDerived; + } + + + + // @info.archinnov.achilles.annotations.Column("isEnd") + private Boolean isEnd; + + @JsonGetter + @javax.persistence.Column(name = "isEnd", table = "FeatureChainExpression") + public Boolean getIsEnd() { + return isEnd; + } + + @JsonSetter + public void setIsEnd(Boolean isEnd) { + this.isEnd = isEnd; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("isModelLevelEvaluable") + private Boolean isModelLevelEvaluable; + + @JsonGetter + // @javax.persistence.Transient + @javax.persistence.Column(name = "isModelLevelEvaluable", table = "FeatureChainExpression") + public Boolean getIsModelLevelEvaluable() { + return isModelLevelEvaluable; + } + + @JsonSetter + public void setIsModelLevelEvaluable(Boolean isModelLevelEvaluable) { + this.isModelLevelEvaluable = isModelLevelEvaluable; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("isNonunique") + private Boolean isNonunique; + + @JsonGetter + // @javax.persistence.Transient + @javax.persistence.Column(name = "isNonunique", table = "FeatureChainExpression") + public Boolean getIsNonunique() { + return isNonunique; + } + + @JsonSetter + public void setIsNonunique(Boolean isNonunique) { + this.isNonunique = isNonunique; + } + + + + // @info.archinnov.achilles.annotations.Column("isOrdered") + private Boolean isOrdered; + + @JsonGetter + @javax.persistence.Column(name = "isOrdered", table = "FeatureChainExpression") + public Boolean getIsOrdered() { + return isOrdered; + } + + @JsonSetter + public void setIsOrdered(Boolean isOrdered) { + this.isOrdered = isOrdered; + } + + + + // @info.archinnov.achilles.annotations.Column("isPortion") + private Boolean isPortion; + + @JsonGetter + @javax.persistence.Column(name = "isPortion", table = "FeatureChainExpression") + public Boolean getIsPortion() { + return isPortion; + } + + @JsonSetter + public void setIsPortion(Boolean isPortion) { + this.isPortion = isPortion; + } + + + + // @info.archinnov.achilles.annotations.Column("isReadOnly") + private Boolean isReadOnly; + + @JsonGetter + @javax.persistence.Column(name = "isReadOnly", table = "FeatureChainExpression") + public Boolean getIsReadOnly() { + return isReadOnly; + } + + @JsonSetter + public void setIsReadOnly(Boolean isReadOnly) { + this.isReadOnly = isReadOnly; + } + + + + // @info.archinnov.achilles.annotations.Column("isSufficient") + private Boolean isSufficient; + + @JsonGetter + @javax.persistence.Column(name = "isSufficient", table = "FeatureChainExpression") + public Boolean getIsSufficient() { + return isSufficient; + } + + @JsonSetter + public void setIsSufficient(Boolean isSufficient) { + this.isSufficient = isSufficient; + } + + + + // @info.archinnov.achilles.annotations.Column("isUnique") + private Boolean isUnique; + + @JsonGetter + @javax.persistence.Column(name = "isUnique", table = "FeatureChainExpression") + public Boolean getIsUnique() { + return isUnique; + } + + @JsonSetter + public void setIsUnique(Boolean isUnique) { + this.isUnique = isUnique; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("member") + private List member; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_member", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getMember() { + if (member == null) { + member = new ArrayList<>(); + } + return member; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = ElementImpl.class) + public void setMember(List member) { + this.member = member; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("membership") + private List membership; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_membership", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getMembership() { + if (membership == null) { + membership = new ArrayList<>(); + } + return membership; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = MembershipImpl.class) + public void setMembership(List membership) { + this.membership = membership; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("multiplicity") + private Multiplicity multiplicity; + + @JsonGetter + @JsonSerialize(using = DataSerializer.class) + // @javax.persistence.Transient + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicityId", table = "FeatureChainExpression") + public Multiplicity getMultiplicity() { + return multiplicity; + } + + @JsonSetter + @JsonDeserialize(using = DataDeserializer.class, as = MultiplicityImpl.class) + public void setMultiplicity(Multiplicity multiplicity) { + this.multiplicity = multiplicity; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("name") + private String name; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "name", table = "FeatureChainExpression") + public String getName() { + return name; + } + + @JsonSetter + public void setName(String name) { + this.name = name; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("operand") + private List operand; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_operand", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getOperand() { + if (operand == null) { + operand = new ArrayList<>(); + } + return operand; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = ExpressionImpl.class) + public void setOperand(List operand) { + this.operand = operand; + } + + + + // @info.archinnov.achilles.annotations.Column("operator") + private String operator; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "operator", table = "FeatureChainExpression") + public String getOperator() { + return operator; + } + + @JsonSetter + public void setOperator(String operator) { + this.operator = operator; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("output") + private List output; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_output", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getOutput() { + if (output == null) { + output = new ArrayList<>(); + } + return output; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = FeatureImpl.class) + public void setOutput(List output) { + this.output = output; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedAnnotation") + private List ownedAnnotation; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_ownedAnnotation", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getOwnedAnnotation() { + if (ownedAnnotation == null) { + ownedAnnotation = new ArrayList<>(); + } + return ownedAnnotation; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = AnnotationImpl.class) + public void setOwnedAnnotation(List ownedAnnotation) { + this.ownedAnnotation = ownedAnnotation; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedConjugator") + private Conjugation ownedConjugator; + + @JsonGetter + @JsonSerialize(using = DataSerializer.class) + // @javax.persistence.Transient + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugatorId", table = "FeatureChainExpression") + public Conjugation getOwnedConjugator() { + return ownedConjugator; + } + + @JsonSetter + @JsonDeserialize(using = DataDeserializer.class, as = ConjugationImpl.class) + public void setOwnedConjugator(Conjugation ownedConjugator) { + this.ownedConjugator = ownedConjugator; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedDisjoining") + private Collection ownedDisjoining; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_ownedDisjoining", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public Collection getOwnedDisjoining() { + if (ownedDisjoining == null) { + ownedDisjoining = new ArrayList<>(); + } + return ownedDisjoining; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = DisjoiningImpl.class) + public void setOwnedDisjoining(Collection ownedDisjoining) { + this.ownedDisjoining = ownedDisjoining; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedElement") + private List ownedElement; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_ownedElement", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getOwnedElement() { + if (ownedElement == null) { + ownedElement = new ArrayList<>(); + } + return ownedElement; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = ElementImpl.class) + public void setOwnedElement(List ownedElement) { + this.ownedElement = ownedElement; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedEndFeature") + private List ownedEndFeature; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_ownedEndFeature", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getOwnedEndFeature() { + if (ownedEndFeature == null) { + ownedEndFeature = new ArrayList<>(); + } + return ownedEndFeature; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = FeatureImpl.class) + public void setOwnedEndFeature(List ownedEndFeature) { + this.ownedEndFeature = ownedEndFeature; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedFeature") + private List ownedFeature; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_ownedFeature", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getOwnedFeature() { + if (ownedFeature == null) { + ownedFeature = new ArrayList<>(); + } + return ownedFeature; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = FeatureImpl.class) + public void setOwnedFeature(List ownedFeature) { + this.ownedFeature = ownedFeature; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedFeatureChaining") + private List ownedFeatureChaining; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_ownedFeatureChaining", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getOwnedFeatureChaining() { + if (ownedFeatureChaining == null) { + ownedFeatureChaining = new ArrayList<>(); + } + return ownedFeatureChaining; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = FeatureChainingImpl.class) + public void setOwnedFeatureChaining(List ownedFeatureChaining) { + this.ownedFeatureChaining = ownedFeatureChaining; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedFeatureMembership") + private List ownedFeatureMembership; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_ownedFeatureMembership", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getOwnedFeatureMembership() { + if (ownedFeatureMembership == null) { + ownedFeatureMembership = new ArrayList<>(); + } + return ownedFeatureMembership; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = FeatureMembershipImpl.class) + public void setOwnedFeatureMembership(List ownedFeatureMembership) { + this.ownedFeatureMembership = ownedFeatureMembership; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedImport") + private List ownedImport; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_ownedImport", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getOwnedImport() { + if (ownedImport == null) { + ownedImport = new ArrayList<>(); + } + return ownedImport; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = ImportImpl.class) + public void setOwnedImport(List ownedImport) { + this.ownedImport = ownedImport; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMember") + private List ownedMember; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_ownedMember", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getOwnedMember() { + if (ownedMember == null) { + ownedMember = new ArrayList<>(); + } + return ownedMember; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = ElementImpl.class) + public void setOwnedMember(List ownedMember) { + this.ownedMember = ownedMember; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMembership") + private List ownedMembership; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_ownedMembership", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getOwnedMembership() { + if (ownedMembership == null) { + ownedMembership = new ArrayList<>(); + } + return ownedMembership; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = MembershipImpl.class) + public void setOwnedMembership(List ownedMembership) { + this.ownedMembership = ownedMembership; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedRedefinition") + private Collection ownedRedefinition; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_ownedRedefinition", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public Collection getOwnedRedefinition() { + if (ownedRedefinition == null) { + ownedRedefinition = new ArrayList<>(); + } + return ownedRedefinition; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = RedefinitionImpl.class) + public void setOwnedRedefinition(Collection ownedRedefinition) { + this.ownedRedefinition = ownedRedefinition; + } + + + + // @info.archinnov.achilles.annotations.Column("ownedRelationship") + private List ownedRelationship; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_ownedRelationship", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getOwnedRelationship() { + if (ownedRelationship == null) { + ownedRelationship = new ArrayList<>(); + } + return ownedRelationship; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = RelationshipImpl.class) + public void setOwnedRelationship(List ownedRelationship) { + this.ownedRelationship = ownedRelationship; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedSpecialization") + private List ownedSpecialization; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_ownedSpecialization", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getOwnedSpecialization() { + if (ownedSpecialization == null) { + ownedSpecialization = new ArrayList<>(); + } + return ownedSpecialization; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = SpecializationImpl.class) + public void setOwnedSpecialization(List ownedSpecialization) { + this.ownedSpecialization = ownedSpecialization; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedSubsetting") + private Collection ownedSubsetting; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_ownedSubsetting", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public Collection getOwnedSubsetting() { + if (ownedSubsetting == null) { + ownedSubsetting = new ArrayList<>(); + } + return ownedSubsetting; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = SubsettingImpl.class) + public void setOwnedSubsetting(Collection ownedSubsetting) { + this.ownedSubsetting = ownedSubsetting; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedTextualRepresentation") + private Collection ownedTextualRepresentation; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_ownedTextualRepresentation", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public Collection getOwnedTextualRepresentation() { + if (ownedTextualRepresentation == null) { + ownedTextualRepresentation = new ArrayList<>(); + } + return ownedTextualRepresentation; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = TextualRepresentationImpl.class) + public void setOwnedTextualRepresentation(Collection ownedTextualRepresentation) { + this.ownedTextualRepresentation = ownedTextualRepresentation; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedTypeFeaturing") + private List ownedTypeFeaturing; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_ownedTypeFeaturing", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getOwnedTypeFeaturing() { + if (ownedTypeFeaturing == null) { + ownedTypeFeaturing = new ArrayList<>(); + } + return ownedTypeFeaturing; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = TypeFeaturingImpl.class) + public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { + this.ownedTypeFeaturing = ownedTypeFeaturing; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedTyping") + private List ownedTyping; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_ownedTyping", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getOwnedTyping() { + if (ownedTyping == null) { + ownedTyping = new ArrayList<>(); + } + return ownedTyping; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = FeatureTypingImpl.class) + public void setOwnedTyping(List ownedTyping) { + this.ownedTyping = ownedTyping; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("owner") + private Element owner; + + @JsonGetter + @JsonSerialize(using = DataSerializer.class) + // @javax.persistence.Transient + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownerId", table = "FeatureChainExpression") + public Element getOwner() { + return owner; + } + + @JsonSetter + @JsonDeserialize(using = DataDeserializer.class, as = ElementImpl.class) + public void setOwner(Element owner) { + this.owner = owner; + } + + + + // @info.archinnov.achilles.annotations.Column("owningFeatureMembership") + private FeatureMembership owningFeatureMembership; + + @JsonGetter + @JsonSerialize(using = DataSerializer.class) + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembershipId", table = "FeatureChainExpression") + public FeatureMembership getOwningFeatureMembership() { + return owningFeatureMembership; + } + + @JsonSetter + @JsonDeserialize(using = DataDeserializer.class, as = FeatureMembershipImpl.class) + public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership) { + this.owningFeatureMembership = owningFeatureMembership; + } + + + + // @info.archinnov.achilles.annotations.Column("owningMembership") + private Membership owningMembership; + + @JsonGetter + @JsonSerialize(using = DataSerializer.class) + @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembershipId", table = "FeatureChainExpression") + public Membership getOwningMembership() { + return owningMembership; + } + + @JsonSetter + @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) + public void setOwningMembership(Membership owningMembership) { + this.owningMembership = owningMembership; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("owningNamespace") + private Namespace owningNamespace; + + @JsonGetter + @JsonSerialize(using = DataSerializer.class) + // @javax.persistence.Transient + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespaceId", table = "FeatureChainExpression") + public Namespace getOwningNamespace() { + return owningNamespace; + } + + @JsonSetter + @JsonDeserialize(using = DataDeserializer.class, as = NamespaceImpl.class) + public void setOwningNamespace(Namespace owningNamespace) { + this.owningNamespace = owningNamespace; + } + + + + // @info.archinnov.achilles.annotations.Column("owningRelationship") + private Relationship owningRelationship; + + @JsonGetter + @JsonSerialize(using = DataSerializer.class) + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationshipId", table = "FeatureChainExpression") + public Relationship getOwningRelationship() { + return owningRelationship; + } + + @JsonSetter + @JsonDeserialize(using = DataDeserializer.class, as = RelationshipImpl.class) + public void setOwningRelationship(Relationship owningRelationship) { + this.owningRelationship = owningRelationship; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("owningType") + private Type owningType; + + @JsonGetter + @JsonSerialize(using = DataSerializer.class) + // @javax.persistence.Transient + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningTypeId", table = "FeatureChainExpression") + public Type getOwningType() { + return owningType; + } + + @JsonSetter + @JsonDeserialize(using = DataDeserializer.class, as = TypeImpl.class) + public void setOwningType(Type owningType) { + this.owningType = owningType; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("parameter") + private List parameter; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_parameter", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getParameter() { + if (parameter == null) { + parameter = new ArrayList<>(); + } + return parameter; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = FeatureImpl.class) + public void setParameter(List parameter) { + this.parameter = parameter; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("qualifiedName") + private String qualifiedName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "qualifiedName", table = "FeatureChainExpression") + public String getQualifiedName() { + return qualifiedName; + } + + @JsonSetter + public void setQualifiedName(String qualifiedName) { + this.qualifiedName = qualifiedName; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("result") + private Feature result; + + @JsonGetter + @JsonSerialize(using = DataSerializer.class) + // @javax.persistence.Transient + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) + @JoinColumn(name = "resultId", table = "FeatureChainExpression") + public Feature getResult() { + return result; + } + + @JsonSetter + @JsonDeserialize(using = DataDeserializer.class, as = FeatureImpl.class) + public void setResult(Feature result) { + this.result = result; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("targetFeature") + private Feature targetFeature; + + @JsonGetter + @JsonSerialize(using = DataSerializer.class) + // @javax.persistence.Transient + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "targetFeatureType"), fetch = FetchType.LAZY) + @JoinColumn(name = "targetFeatureId", table = "FeatureChainExpression") + public Feature getTargetFeature() { + return targetFeature; + } + + @JsonSetter + @JsonDeserialize(using = DataDeserializer.class, as = FeatureImpl.class) + public void setTargetFeature(Feature targetFeature) { + this.targetFeature = targetFeature; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("type") + private List type; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @JoinTable(name = "FeatureChainExpression_type", + joinColumns = @JoinColumn(name = "classId"), + inverseJoinColumns = @JoinColumn(name = "attributeId")) + public List getType() { + if (type == null) { + type = new ArrayList<>(); + } + return type; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = TypeImpl.class) + public void setType(List type) { + this.type = type; + } + + + +} diff --git a/app/org/omg/sysml/metamodel/impl/PathSelectExpressionImpl.java b/app/org/omg/sysml/metamodel/impl/SelectExpressionImpl.java similarity index 91% rename from app/org/omg/sysml/metamodel/impl/PathSelectExpressionImpl.java rename to app/org/omg/sysml/metamodel/impl/SelectExpressionImpl.java index 0f298d46..e0f4e426 100644 --- a/app/org/omg/sysml/metamodel/impl/PathSelectExpressionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/SelectExpressionImpl.java @@ -61,14 +61,14 @@ import java.util.Set; import java.util.HashSet; -@Entity(name = "PathSelectExpressionImpl") -@SecondaryTable(name = "PathSelectExpression") -@org.hibernate.annotations.Table(appliesTo = "PathSelectExpression", fetch = FetchMode.SELECT, optional = false) -// @info.archinnov.achilles.annotations.Table(table = "PathSelectExpression") -@DiscriminatorValue(value = "PathSelectExpression") -@JsonTypeName(value = "PathSelectExpression") +@Entity(name = "SelectExpressionImpl") +@SecondaryTable(name = "SelectExpression") +@org.hibernate.annotations.Table(appliesTo = "SelectExpression", fetch = FetchMode.SELECT, optional = false) +// @info.archinnov.achilles.annotations.Table(table = "SelectExpression") +@DiscriminatorValue(value = "SelectExpression") +@JsonTypeName(value = "SelectExpression") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) -public class PathSelectExpressionImpl extends SysMLTypeImpl implements PathSelectExpression { +public class SelectExpressionImpl extends SysMLTypeImpl implements SelectExpression { // @info.archinnov.achilles.annotations.Column("aliasId") private List aliasId; @@ -76,8 +76,8 @@ public class PathSelectExpressionImpl extends SysMLTypeImpl implements PathSelec @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "PathSelectExpression_aliasId", - joinColumns = @JoinColumn(name = "PathSelectExpressionId")) + @CollectionTable(name = "SelectExpression_aliasId", + joinColumns = @JoinColumn(name = "SelectExpressionId")) public List getAliasId() { if (aliasId == null) { aliasId = new ArrayList<>(); @@ -100,7 +100,7 @@ public void setAliasId(List aliasId) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_argument", + @JoinTable(name = "SelectExpression_argument", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getArgument() { @@ -126,7 +126,7 @@ public void setArgument(List argument) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_behavior", + @JoinTable(name = "SelectExpression_behavior", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getBehavior() { @@ -152,7 +152,7 @@ public void setBehavior(List behavior) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_chainingFeature", + @JoinTable(name = "SelectExpression_chainingFeature", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getChainingFeature() { @@ -178,7 +178,7 @@ public void setChainingFeature(List chainingFeature) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_directedFeature", + @JoinTable(name = "SelectExpression_directedFeature", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getDirectedFeature() { @@ -202,7 +202,7 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @javax.persistence.Enumerated(EnumType.STRING) - @javax.persistence.Column(name = "direction", table = "PathSelectExpression") + @javax.persistence.Column(name = "direction", table = "SelectExpression") public FeatureDirectionKind getDirection() { return direction; } @@ -222,7 +222,7 @@ public void setDirection(FeatureDirectionKind direction) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_documentation", + @JoinTable(name = "SelectExpression_documentation", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getDocumentation() { @@ -248,7 +248,7 @@ public void setDocumentation(List documentation) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "CommentMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_documentationComment", + @JoinTable(name = "SelectExpression_documentationComment", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getDocumentationComment() { @@ -274,7 +274,7 @@ public void setDocumentationComment(List documentationComment) { @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") // @javax.persistence.Transient - @javax.persistence.Column(name = "effectiveName", table = "PathSelectExpression") + @javax.persistence.Column(name = "effectiveName", table = "SelectExpression") public String getEffectiveName() { return effectiveName; } @@ -294,7 +294,7 @@ public void setEffectiveName(String effectiveName) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_endFeature", + @JoinTable(name = "SelectExpression_endFeature", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getEndFeature() { @@ -320,7 +320,7 @@ public void setEndFeature(List endFeature) { @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "PathSelectExpression") + @JoinColumn(name = "endOwningTypeId", table = "SelectExpression") public Type getEndOwningType() { return endOwningType; } @@ -341,7 +341,7 @@ public void setEndOwningType(Type endOwningType) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_feature", + @JoinTable(name = "SelectExpression_feature", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getFeature() { @@ -367,7 +367,7 @@ public void setFeature(List feature) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_featureMembership", + @JoinTable(name = "SelectExpression_featureMembership", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getFeatureMembership() { @@ -393,7 +393,7 @@ public void setFeatureMembership(List featureMembership) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_featuringType", + @JoinTable(name = "SelectExpression_featuringType", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getFeaturingType() { @@ -419,7 +419,7 @@ public void setFeaturingType(List featuringType) { @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "PathSelectExpression") + @JoinColumn(name = "functionId", table = "SelectExpression") public Function getFunction() { return function; } @@ -438,7 +438,7 @@ public void setFunction(Function function) { @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "PathSelectExpression") + @javax.persistence.Column(name = "humanId", table = "SelectExpression") public String getHumanId() { return humanId; } @@ -454,7 +454,7 @@ public void setHumanId(String humanId) { private java.util.UUID identifier; @JsonGetter - @javax.persistence.Column(name = "identifier", table = "PathSelectExpression") + @javax.persistence.Column(name = "identifier", table = "SelectExpression") public java.util.UUID getIdentifier() { return identifier; } @@ -474,7 +474,7 @@ public void setIdentifier(java.util.UUID identifier) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_importedMembership", + @JoinTable(name = "SelectExpression_importedMembership", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getImportedMembership() { @@ -500,7 +500,7 @@ public void setImportedMembership(List importedMembership) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_inheritedFeature", + @JoinTable(name = "SelectExpression_inheritedFeature", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getInheritedFeature() { @@ -526,7 +526,7 @@ public void setInheritedFeature(List inheritedFeature) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_inheritedMembership", + @JoinTable(name = "SelectExpression_inheritedMembership", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getInheritedMembership() { @@ -552,7 +552,7 @@ public void setInheritedMembership(List inheritedMembership) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_input", + @JoinTable(name = "SelectExpression_input", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getInput() { @@ -574,7 +574,7 @@ public void setInput(List input) { private Boolean isAbstract; @JsonGetter - @javax.persistence.Column(name = "isAbstract", table = "PathSelectExpression") + @javax.persistence.Column(name = "isAbstract", table = "SelectExpression") public Boolean getIsAbstract() { return isAbstract; } @@ -590,7 +590,7 @@ public void setIsAbstract(Boolean isAbstract) { private Boolean isComposite; @JsonGetter - @javax.persistence.Column(name = "isComposite", table = "PathSelectExpression") + @javax.persistence.Column(name = "isComposite", table = "SelectExpression") public Boolean getIsComposite() { return isComposite; } @@ -608,7 +608,7 @@ public void setIsComposite(Boolean isComposite) { @JsonGetter // @javax.persistence.Transient - @javax.persistence.Column(name = "isConjugated", table = "PathSelectExpression") + @javax.persistence.Column(name = "isConjugated", table = "SelectExpression") public Boolean getIsConjugated() { return isConjugated; } @@ -624,7 +624,7 @@ public void setIsConjugated(Boolean isConjugated) { private Boolean isDerived; @JsonGetter - @javax.persistence.Column(name = "isDerived", table = "PathSelectExpression") + @javax.persistence.Column(name = "isDerived", table = "SelectExpression") public Boolean getIsDerived() { return isDerived; } @@ -640,7 +640,7 @@ public void setIsDerived(Boolean isDerived) { private Boolean isEnd; @JsonGetter - @javax.persistence.Column(name = "isEnd", table = "PathSelectExpression") + @javax.persistence.Column(name = "isEnd", table = "SelectExpression") public Boolean getIsEnd() { return isEnd; } @@ -658,7 +658,7 @@ public void setIsEnd(Boolean isEnd) { @JsonGetter // @javax.persistence.Transient - @javax.persistence.Column(name = "isModelLevelEvaluable", table = "PathSelectExpression") + @javax.persistence.Column(name = "isModelLevelEvaluable", table = "SelectExpression") public Boolean getIsModelLevelEvaluable() { return isModelLevelEvaluable; } @@ -676,7 +676,7 @@ public void setIsModelLevelEvaluable(Boolean isModelLevelEvaluable) { @JsonGetter // @javax.persistence.Transient - @javax.persistence.Column(name = "isNonunique", table = "PathSelectExpression") + @javax.persistence.Column(name = "isNonunique", table = "SelectExpression") public Boolean getIsNonunique() { return isNonunique; } @@ -692,7 +692,7 @@ public void setIsNonunique(Boolean isNonunique) { private Boolean isOrdered; @JsonGetter - @javax.persistence.Column(name = "isOrdered", table = "PathSelectExpression") + @javax.persistence.Column(name = "isOrdered", table = "SelectExpression") public Boolean getIsOrdered() { return isOrdered; } @@ -708,7 +708,7 @@ public void setIsOrdered(Boolean isOrdered) { private Boolean isPortion; @JsonGetter - @javax.persistence.Column(name = "isPortion", table = "PathSelectExpression") + @javax.persistence.Column(name = "isPortion", table = "SelectExpression") public Boolean getIsPortion() { return isPortion; } @@ -724,7 +724,7 @@ public void setIsPortion(Boolean isPortion) { private Boolean isReadOnly; @JsonGetter - @javax.persistence.Column(name = "isReadOnly", table = "PathSelectExpression") + @javax.persistence.Column(name = "isReadOnly", table = "SelectExpression") public Boolean getIsReadOnly() { return isReadOnly; } @@ -740,7 +740,7 @@ public void setIsReadOnly(Boolean isReadOnly) { private Boolean isSufficient; @JsonGetter - @javax.persistence.Column(name = "isSufficient", table = "PathSelectExpression") + @javax.persistence.Column(name = "isSufficient", table = "SelectExpression") public Boolean getIsSufficient() { return isSufficient; } @@ -756,7 +756,7 @@ public void setIsSufficient(Boolean isSufficient) { private Boolean isUnique; @JsonGetter - @javax.persistence.Column(name = "isUnique", table = "PathSelectExpression") + @javax.persistence.Column(name = "isUnique", table = "SelectExpression") public Boolean getIsUnique() { return isUnique; } @@ -776,7 +776,7 @@ public void setIsUnique(Boolean isUnique) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_member", + @JoinTable(name = "SelectExpression_member", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getMember() { @@ -802,7 +802,7 @@ public void setMember(List member) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_membership", + @JoinTable(name = "SelectExpression_membership", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getMembership() { @@ -828,7 +828,7 @@ public void setMembership(List membership) { @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "PathSelectExpression") + @JoinColumn(name = "multiplicityId", table = "SelectExpression") public Multiplicity getMultiplicity() { return multiplicity; } @@ -849,7 +849,7 @@ public void setMultiplicity(Multiplicity multiplicity) { @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") // @javax.persistence.Transient - @javax.persistence.Column(name = "name", table = "PathSelectExpression") + @javax.persistence.Column(name = "name", table = "SelectExpression") public String getName() { return name; } @@ -869,7 +869,7 @@ public void setName(String name) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_operand", + @JoinTable(name = "SelectExpression_operand", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOperand() { @@ -893,7 +893,7 @@ public void setOperand(List operand) { @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "operator", table = "PathSelectExpression") + @javax.persistence.Column(name = "operator", table = "SelectExpression") public String getOperator() { return operator; } @@ -913,7 +913,7 @@ public void setOperator(String operator) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_output", + @JoinTable(name = "SelectExpression_output", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOutput() { @@ -939,7 +939,7 @@ public void setOutput(List output) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_ownedAnnotation", + @JoinTable(name = "SelectExpression_ownedAnnotation", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedAnnotation() { @@ -965,7 +965,7 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "PathSelectExpression") + @JoinColumn(name = "ownedConjugatorId", table = "SelectExpression") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -986,7 +986,7 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_ownedDisjoining", + @JoinTable(name = "SelectExpression_ownedDisjoining", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public Collection getOwnedDisjoining() { @@ -1012,7 +1012,7 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_ownedElement", + @JoinTable(name = "SelectExpression_ownedElement", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedElement() { @@ -1038,7 +1038,7 @@ public void setOwnedElement(List ownedElement) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_ownedEndFeature", + @JoinTable(name = "SelectExpression_ownedEndFeature", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedEndFeature() { @@ -1064,7 +1064,7 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_ownedFeature", + @JoinTable(name = "SelectExpression_ownedFeature", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedFeature() { @@ -1090,7 +1090,7 @@ public void setOwnedFeature(List ownedFeature) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_ownedFeatureChaining", + @JoinTable(name = "SelectExpression_ownedFeatureChaining", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedFeatureChaining() { @@ -1116,7 +1116,7 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_ownedFeatureMembership", + @JoinTable(name = "SelectExpression_ownedFeatureMembership", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedFeatureMembership() { @@ -1142,7 +1142,7 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_ownedImport", + @JoinTable(name = "SelectExpression_ownedImport", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedImport() { @@ -1168,7 +1168,7 @@ public void setOwnedImport(List ownedImport) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_ownedMember", + @JoinTable(name = "SelectExpression_ownedMember", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedMember() { @@ -1194,7 +1194,7 @@ public void setOwnedMember(List ownedMember) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_ownedMembership", + @JoinTable(name = "SelectExpression_ownedMembership", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedMembership() { @@ -1220,7 +1220,7 @@ public void setOwnedMembership(List ownedMembership) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_ownedRedefinition", + @JoinTable(name = "SelectExpression_ownedRedefinition", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public Collection getOwnedRedefinition() { @@ -1244,7 +1244,7 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_ownedRelationship", + @JoinTable(name = "SelectExpression_ownedRelationship", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedRelationship() { @@ -1270,7 +1270,7 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_ownedSpecialization", + @JoinTable(name = "SelectExpression_ownedSpecialization", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedSpecialization() { @@ -1296,7 +1296,7 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_ownedSubsetting", + @JoinTable(name = "SelectExpression_ownedSubsetting", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public Collection getOwnedSubsetting() { @@ -1322,7 +1322,7 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_ownedTextualRepresentation", + @JoinTable(name = "SelectExpression_ownedTextualRepresentation", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public Collection getOwnedTextualRepresentation() { @@ -1348,7 +1348,7 @@ public void setOwnedTextualRepresentation(Collection owne @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_ownedTypeFeaturing", + @JoinTable(name = "SelectExpression_ownedTypeFeaturing", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedTypeFeaturing() { @@ -1374,7 +1374,7 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_ownedTyping", + @JoinTable(name = "SelectExpression_ownedTyping", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getOwnedTyping() { @@ -1400,7 +1400,7 @@ public void setOwnedTyping(List ownedTyping) { @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "PathSelectExpression") + @JoinColumn(name = "ownerId", table = "SelectExpression") public Element getOwner() { return owner; } @@ -1419,7 +1419,7 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "PathSelectExpression") + @JoinColumn(name = "owningFeatureMembershipId", table = "SelectExpression") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1438,7 +1438,7 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership @JsonGetter @JsonSerialize(using = DataSerializer.class) @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "PathSelectExpression") + @JoinColumn(name = "owningMembershipId", table = "SelectExpression") public Membership getOwningMembership() { return owningMembership; } @@ -1459,7 +1459,7 @@ public void setOwningMembership(Membership owningMembership) { @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "PathSelectExpression") + @JoinColumn(name = "owningNamespaceId", table = "SelectExpression") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1478,7 +1478,7 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "PathSelectExpression") + @JoinColumn(name = "owningRelationshipId", table = "SelectExpression") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1499,7 +1499,7 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "PathSelectExpression") + @JoinColumn(name = "owningTypeId", table = "SelectExpression") public Type getOwningType() { return owningType; } @@ -1520,7 +1520,7 @@ public void setOwningType(Type owningType) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_parameter", + @JoinTable(name = "SelectExpression_parameter", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getParameter() { @@ -1546,7 +1546,7 @@ public void setParameter(List parameter) { @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") // @javax.persistence.Transient - @javax.persistence.Column(name = "qualifiedName", table = "PathSelectExpression") + @javax.persistence.Column(name = "qualifiedName", table = "SelectExpression") public String getQualifiedName() { return qualifiedName; } @@ -1566,7 +1566,7 @@ public void setQualifiedName(String qualifiedName) { @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "PathSelectExpression") + @JoinColumn(name = "resultId", table = "SelectExpression") public Feature getResult() { return result; } @@ -1587,7 +1587,7 @@ public void setResult(Feature result) { @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) - @JoinTable(name = "PathSelectExpression_type", + @JoinTable(name = "SelectExpression_type", joinColumns = @JoinColumn(name = "classId"), inverseJoinColumns = @JoinColumn(name = "attributeId")) public List getType() { diff --git a/app/org/omg/sysml/metamodel/impl/package-info.java b/app/org/omg/sysml/metamodel/impl/package-info.java index 44c361b2..7dc1f64d 100644 --- a/app/org/omg/sysml/metamodel/impl/package-info.java +++ b/app/org/omg/sysml/metamodel/impl/package-info.java @@ -50,6 +50,7 @@ @MetaValue(value = "CaseUsage", targetEntity = CaseUsageImpl.class), @MetaValue(value = "Class", targetEntity = ClassImpl.class), @MetaValue(value = "Classifier", targetEntity = ClassifierImpl.class), + @MetaValue(value = "CollectExpression", targetEntity = CollectExpressionImpl.class), @MetaValue(value = "Comment", targetEntity = CommentImpl.class), @MetaValue(value = "ConcernDefinition", targetEntity = ConcernDefinitionImpl.class), @MetaValue(value = "ConcernUsage", targetEntity = ConcernUsageImpl.class), @@ -79,6 +80,7 @@ @MetaValue(value = "Expose", targetEntity = ExposeImpl.class), @MetaValue(value = "Expression", targetEntity = ExpressionImpl.class), @MetaValue(value = "Feature", targetEntity = FeatureImpl.class), + @MetaValue(value = "FeatureChainExpression", targetEntity = FeatureChainExpressionImpl.class), @MetaValue(value = "FeatureChaining", targetEntity = FeatureChainingImpl.class), @MetaValue(value = "FeatureMembership", targetEntity = FeatureMembershipImpl.class), @MetaValue(value = "FeatureReferenceExpression", targetEntity = FeatureReferenceExpressionImpl.class), @@ -128,8 +130,6 @@ @MetaValue(value = "ParameterMembership", targetEntity = ParameterMembershipImpl.class), @MetaValue(value = "PartDefinition", targetEntity = PartDefinitionImpl.class), @MetaValue(value = "PartUsage", targetEntity = PartUsageImpl.class), - @MetaValue(value = "PathSelectExpression", targetEntity = PathSelectExpressionImpl.class), - @MetaValue(value = "PathStepExpression", targetEntity = PathStepExpressionImpl.class), @MetaValue(value = "PerformActionUsage", targetEntity = PerformActionUsageImpl.class), @MetaValue(value = "PortConjugation", targetEntity = PortConjugationImpl.class), @MetaValue(value = "PortDefinition", targetEntity = PortDefinitionImpl.class), @@ -148,6 +148,7 @@ @MetaValue(value = "ResultExpressionMembership", targetEntity = ResultExpressionMembershipImpl.class), @MetaValue(value = "ReturnParameterMembership", targetEntity = ReturnParameterMembershipImpl.class), @MetaValue(value = "SatisfyRequirementUsage", targetEntity = SatisfyRequirementUsageImpl.class), + @MetaValue(value = "SelectExpression", targetEntity = SelectExpressionImpl.class), @MetaValue(value = "SendActionUsage", targetEntity = SendActionUsageImpl.class), @MetaValue(value = "SourceEnd", targetEntity = SourceEndImpl.class), @MetaValue(value = "Specialization", targetEntity = SpecializationImpl.class), @@ -435,6 +436,10 @@ @MetaValue(value = "ViewDefinition", targetEntity = ViewDefinitionImpl.class), @MetaValue(value = "ViewpointDefinition", targetEntity = ViewpointDefinitionImpl.class), }), + @AnyMetaDef(name = "CollectExpressionMetaDef", metaType = "string", idType = "java.util.UUID", + metaValues = { + @MetaValue(value = "CollectExpression", targetEntity = CollectExpressionImpl.class), + }), @AnyMetaDef(name = "CommentMetaDef", metaType = "string", idType = "java.util.UUID", metaValues = { @MetaValue(value = "Comment", targetEntity = CommentImpl.class), @@ -603,6 +608,7 @@ @MetaValue(value = "CaseUsage", targetEntity = CaseUsageImpl.class), @MetaValue(value = "Class", targetEntity = ClassImpl.class), @MetaValue(value = "Classifier", targetEntity = ClassifierImpl.class), + @MetaValue(value = "CollectExpression", targetEntity = CollectExpressionImpl.class), @MetaValue(value = "Comment", targetEntity = CommentImpl.class), @MetaValue(value = "ConcernDefinition", targetEntity = ConcernDefinitionImpl.class), @MetaValue(value = "ConcernUsage", targetEntity = ConcernUsageImpl.class), @@ -632,6 +638,7 @@ @MetaValue(value = "Expose", targetEntity = ExposeImpl.class), @MetaValue(value = "Expression", targetEntity = ExpressionImpl.class), @MetaValue(value = "Feature", targetEntity = FeatureImpl.class), + @MetaValue(value = "FeatureChainExpression", targetEntity = FeatureChainExpressionImpl.class), @MetaValue(value = "FeatureChaining", targetEntity = FeatureChainingImpl.class), @MetaValue(value = "FeatureMembership", targetEntity = FeatureMembershipImpl.class), @MetaValue(value = "FeatureReferenceExpression", targetEntity = FeatureReferenceExpressionImpl.class), @@ -681,8 +688,6 @@ @MetaValue(value = "ParameterMembership", targetEntity = ParameterMembershipImpl.class), @MetaValue(value = "PartDefinition", targetEntity = PartDefinitionImpl.class), @MetaValue(value = "PartUsage", targetEntity = PartUsageImpl.class), - @MetaValue(value = "PathSelectExpression", targetEntity = PathSelectExpressionImpl.class), - @MetaValue(value = "PathStepExpression", targetEntity = PathStepExpressionImpl.class), @MetaValue(value = "PerformActionUsage", targetEntity = PerformActionUsageImpl.class), @MetaValue(value = "PortConjugation", targetEntity = PortConjugationImpl.class), @MetaValue(value = "PortDefinition", targetEntity = PortDefinitionImpl.class), @@ -701,6 +706,7 @@ @MetaValue(value = "ResultExpressionMembership", targetEntity = ResultExpressionMembershipImpl.class), @MetaValue(value = "ReturnParameterMembership", targetEntity = ReturnParameterMembershipImpl.class), @MetaValue(value = "SatisfyRequirementUsage", targetEntity = SatisfyRequirementUsageImpl.class), + @MetaValue(value = "SelectExpression", targetEntity = SelectExpressionImpl.class), @MetaValue(value = "SendActionUsage", targetEntity = SendActionUsageImpl.class), @MetaValue(value = "SourceEnd", targetEntity = SourceEndImpl.class), @MetaValue(value = "Specialization", targetEntity = SpecializationImpl.class), @@ -775,9 +781,11 @@ @MetaValue(value = "BooleanExpression", targetEntity = BooleanExpressionImpl.class), @MetaValue(value = "CalculationUsage", targetEntity = CalculationUsageImpl.class), @MetaValue(value = "CaseUsage", targetEntity = CaseUsageImpl.class), + @MetaValue(value = "CollectExpression", targetEntity = CollectExpressionImpl.class), @MetaValue(value = "ConcernUsage", targetEntity = ConcernUsageImpl.class), @MetaValue(value = "ConstraintUsage", targetEntity = ConstraintUsageImpl.class), @MetaValue(value = "Expression", targetEntity = ExpressionImpl.class), + @MetaValue(value = "FeatureChainExpression", targetEntity = FeatureChainExpressionImpl.class), @MetaValue(value = "FeatureReferenceExpression", targetEntity = FeatureReferenceExpressionImpl.class), @MetaValue(value = "IncludeUseCaseUsage", targetEntity = IncludeUseCaseUsageImpl.class), @MetaValue(value = "Invariant", targetEntity = InvariantImpl.class), @@ -790,10 +798,9 @@ @MetaValue(value = "LiteralString", targetEntity = LiteralStringImpl.class), @MetaValue(value = "NullExpression", targetEntity = NullExpressionImpl.class), @MetaValue(value = "OperatorExpression", targetEntity = OperatorExpressionImpl.class), - @MetaValue(value = "PathSelectExpression", targetEntity = PathSelectExpressionImpl.class), - @MetaValue(value = "PathStepExpression", targetEntity = PathStepExpressionImpl.class), @MetaValue(value = "RequirementUsage", targetEntity = RequirementUsageImpl.class), @MetaValue(value = "SatisfyRequirementUsage", targetEntity = SatisfyRequirementUsageImpl.class), + @MetaValue(value = "SelectExpression", targetEntity = SelectExpressionImpl.class), @MetaValue(value = "TriggerInvocationExpression", targetEntity = TriggerInvocationExpressionImpl.class), @MetaValue(value = "UseCaseUsage", targetEntity = UseCaseUsageImpl.class), @MetaValue(value = "VerificationCaseUsage", targetEntity = VerificationCaseUsageImpl.class), @@ -814,6 +821,7 @@ @MetaValue(value = "BooleanExpression", targetEntity = BooleanExpressionImpl.class), @MetaValue(value = "CalculationUsage", targetEntity = CalculationUsageImpl.class), @MetaValue(value = "CaseUsage", targetEntity = CaseUsageImpl.class), + @MetaValue(value = "CollectExpression", targetEntity = CollectExpressionImpl.class), @MetaValue(value = "ConcernUsage", targetEntity = ConcernUsageImpl.class), @MetaValue(value = "ConnectionUsage", targetEntity = ConnectionUsageImpl.class), @MetaValue(value = "Connector", targetEntity = ConnectorImpl.class), @@ -826,6 +834,7 @@ @MetaValue(value = "ExhibitStateUsage", targetEntity = ExhibitStateUsageImpl.class), @MetaValue(value = "Expression", targetEntity = ExpressionImpl.class), @MetaValue(value = "Feature", targetEntity = FeatureImpl.class), + @MetaValue(value = "FeatureChainExpression", targetEntity = FeatureChainExpressionImpl.class), @MetaValue(value = "FeatureReferenceExpression", targetEntity = FeatureReferenceExpressionImpl.class), @MetaValue(value = "FlowConnectionUsage", targetEntity = FlowConnectionUsageImpl.class), @MetaValue(value = "ForLoopActionUsage", targetEntity = ForLoopActionUsageImpl.class), @@ -856,8 +865,6 @@ @MetaValue(value = "OccurrenceUsage", targetEntity = OccurrenceUsageImpl.class), @MetaValue(value = "OperatorExpression", targetEntity = OperatorExpressionImpl.class), @MetaValue(value = "PartUsage", targetEntity = PartUsageImpl.class), - @MetaValue(value = "PathSelectExpression", targetEntity = PathSelectExpressionImpl.class), - @MetaValue(value = "PathStepExpression", targetEntity = PathStepExpressionImpl.class), @MetaValue(value = "PerformActionUsage", targetEntity = PerformActionUsageImpl.class), @MetaValue(value = "PortUsage", targetEntity = PortUsageImpl.class), @MetaValue(value = "PortioningFeature", targetEntity = PortioningFeatureImpl.class), @@ -865,6 +872,7 @@ @MetaValue(value = "RenderingUsage", targetEntity = RenderingUsageImpl.class), @MetaValue(value = "RequirementUsage", targetEntity = RequirementUsageImpl.class), @MetaValue(value = "SatisfyRequirementUsage", targetEntity = SatisfyRequirementUsageImpl.class), + @MetaValue(value = "SelectExpression", targetEntity = SelectExpressionImpl.class), @MetaValue(value = "SendActionUsage", targetEntity = SendActionUsageImpl.class), @MetaValue(value = "SourceEnd", targetEntity = SourceEndImpl.class), @MetaValue(value = "StateUsage", targetEntity = StateUsageImpl.class), @@ -883,6 +891,10 @@ @MetaValue(value = "ViewpointUsage", targetEntity = ViewpointUsageImpl.class), @MetaValue(value = "WhileLoopActionUsage", targetEntity = WhileLoopActionUsageImpl.class), }), + @AnyMetaDef(name = "FeatureChainExpressionMetaDef", metaType = "string", idType = "java.util.UUID", + metaValues = { + @MetaValue(value = "FeatureChainExpression", targetEntity = FeatureChainExpressionImpl.class), + }), @AnyMetaDef(name = "FeatureChainingMetaDef", metaType = "string", idType = "java.util.UUID", metaValues = { @MetaValue(value = "FeatureChaining", targetEntity = FeatureChainingImpl.class), @@ -983,10 +995,11 @@ }), @AnyMetaDef(name = "InvocationExpressionMetaDef", metaType = "string", idType = "java.util.UUID", metaValues = { + @MetaValue(value = "CollectExpression", targetEntity = CollectExpressionImpl.class), + @MetaValue(value = "FeatureChainExpression", targetEntity = FeatureChainExpressionImpl.class), @MetaValue(value = "InvocationExpression", targetEntity = InvocationExpressionImpl.class), @MetaValue(value = "OperatorExpression", targetEntity = OperatorExpressionImpl.class), - @MetaValue(value = "PathSelectExpression", targetEntity = PathSelectExpressionImpl.class), - @MetaValue(value = "PathStepExpression", targetEntity = PathStepExpressionImpl.class), + @MetaValue(value = "SelectExpression", targetEntity = SelectExpressionImpl.class), @MetaValue(value = "TriggerInvocationExpression", targetEntity = TriggerInvocationExpressionImpl.class), }), @AnyMetaDef(name = "ItemDefinitionMetaDef", metaType = "string", idType = "java.util.UUID", @@ -1143,6 +1156,7 @@ @MetaValue(value = "CaseUsage", targetEntity = CaseUsageImpl.class), @MetaValue(value = "Class", targetEntity = ClassImpl.class), @MetaValue(value = "Classifier", targetEntity = ClassifierImpl.class), + @MetaValue(value = "CollectExpression", targetEntity = CollectExpressionImpl.class), @MetaValue(value = "ConcernDefinition", targetEntity = ConcernDefinitionImpl.class), @MetaValue(value = "ConcernUsage", targetEntity = ConcernUsageImpl.class), @MetaValue(value = "ConjugatedPortDefinition", targetEntity = ConjugatedPortDefinitionImpl.class), @@ -1162,6 +1176,7 @@ @MetaValue(value = "ExhibitStateUsage", targetEntity = ExhibitStateUsageImpl.class), @MetaValue(value = "Expression", targetEntity = ExpressionImpl.class), @MetaValue(value = "Feature", targetEntity = FeatureImpl.class), + @MetaValue(value = "FeatureChainExpression", targetEntity = FeatureChainExpressionImpl.class), @MetaValue(value = "FeatureReferenceExpression", targetEntity = FeatureReferenceExpressionImpl.class), @MetaValue(value = "FlowConnectionUsage", targetEntity = FlowConnectionUsageImpl.class), @MetaValue(value = "ForLoopActionUsage", targetEntity = ForLoopActionUsageImpl.class), @@ -1201,8 +1216,6 @@ @MetaValue(value = "Package", targetEntity = PackageImpl.class), @MetaValue(value = "PartDefinition", targetEntity = PartDefinitionImpl.class), @MetaValue(value = "PartUsage", targetEntity = PartUsageImpl.class), - @MetaValue(value = "PathSelectExpression", targetEntity = PathSelectExpressionImpl.class), - @MetaValue(value = "PathStepExpression", targetEntity = PathStepExpressionImpl.class), @MetaValue(value = "PerformActionUsage", targetEntity = PerformActionUsageImpl.class), @MetaValue(value = "PortDefinition", targetEntity = PortDefinitionImpl.class), @MetaValue(value = "PortUsage", targetEntity = PortUsageImpl.class), @@ -1214,6 +1227,7 @@ @MetaValue(value = "RequirementDefinition", targetEntity = RequirementDefinitionImpl.class), @MetaValue(value = "RequirementUsage", targetEntity = RequirementUsageImpl.class), @MetaValue(value = "SatisfyRequirementUsage", targetEntity = SatisfyRequirementUsageImpl.class), + @MetaValue(value = "SelectExpression", targetEntity = SelectExpressionImpl.class), @MetaValue(value = "SendActionUsage", targetEntity = SendActionUsageImpl.class), @MetaValue(value = "SourceEnd", targetEntity = SourceEndImpl.class), @MetaValue(value = "StateDefinition", targetEntity = StateDefinitionImpl.class), @@ -1317,9 +1331,10 @@ }), @AnyMetaDef(name = "OperatorExpressionMetaDef", metaType = "string", idType = "java.util.UUID", metaValues = { + @MetaValue(value = "CollectExpression", targetEntity = CollectExpressionImpl.class), + @MetaValue(value = "FeatureChainExpression", targetEntity = FeatureChainExpressionImpl.class), @MetaValue(value = "OperatorExpression", targetEntity = OperatorExpressionImpl.class), - @MetaValue(value = "PathSelectExpression", targetEntity = PathSelectExpressionImpl.class), - @MetaValue(value = "PathStepExpression", targetEntity = PathStepExpressionImpl.class), + @MetaValue(value = "SelectExpression", targetEntity = SelectExpressionImpl.class), }), @AnyMetaDef(name = "PackageMetaDef", metaType = "string", idType = "java.util.UUID", metaValues = { @@ -1353,14 +1368,6 @@ @MetaValue(value = "SuccessionFlowConnectionUsage", targetEntity = SuccessionFlowConnectionUsageImpl.class), @MetaValue(value = "ViewUsage", targetEntity = ViewUsageImpl.class), }), - @AnyMetaDef(name = "PathSelectExpressionMetaDef", metaType = "string", idType = "java.util.UUID", - metaValues = { - @MetaValue(value = "PathSelectExpression", targetEntity = PathSelectExpressionImpl.class), - }), - @AnyMetaDef(name = "PathStepExpressionMetaDef", metaType = "string", idType = "java.util.UUID", - metaValues = { - @MetaValue(value = "PathStepExpression", targetEntity = PathStepExpressionImpl.class), - }), @AnyMetaDef(name = "PerformActionUsageMetaDef", metaType = "string", idType = "java.util.UUID", metaValues = { @MetaValue(value = "ExhibitStateUsage", targetEntity = ExhibitStateUsageImpl.class), @@ -1502,6 +1509,10 @@ metaValues = { @MetaValue(value = "SatisfyRequirementUsage", targetEntity = SatisfyRequirementUsageImpl.class), }), + @AnyMetaDef(name = "SelectExpressionMetaDef", metaType = "string", idType = "java.util.UUID", + metaValues = { + @MetaValue(value = "SelectExpression", targetEntity = SelectExpressionImpl.class), + }), @AnyMetaDef(name = "SendActionUsageMetaDef", metaType = "string", idType = "java.util.UUID", metaValues = { @MetaValue(value = "SendActionUsage", targetEntity = SendActionUsageImpl.class), @@ -1546,12 +1557,14 @@ @MetaValue(value = "BooleanExpression", targetEntity = BooleanExpressionImpl.class), @MetaValue(value = "CalculationUsage", targetEntity = CalculationUsageImpl.class), @MetaValue(value = "CaseUsage", targetEntity = CaseUsageImpl.class), + @MetaValue(value = "CollectExpression", targetEntity = CollectExpressionImpl.class), @MetaValue(value = "ConcernUsage", targetEntity = ConcernUsageImpl.class), @MetaValue(value = "ConstraintUsage", targetEntity = ConstraintUsageImpl.class), @MetaValue(value = "ControlNode", targetEntity = ControlNodeImpl.class), @MetaValue(value = "DecisionNode", targetEntity = DecisionNodeImpl.class), @MetaValue(value = "ExhibitStateUsage", targetEntity = ExhibitStateUsageImpl.class), @MetaValue(value = "Expression", targetEntity = ExpressionImpl.class), + @MetaValue(value = "FeatureChainExpression", targetEntity = FeatureChainExpressionImpl.class), @MetaValue(value = "FeatureReferenceExpression", targetEntity = FeatureReferenceExpressionImpl.class), @MetaValue(value = "FlowConnectionUsage", targetEntity = FlowConnectionUsageImpl.class), @MetaValue(value = "ForLoopActionUsage", targetEntity = ForLoopActionUsageImpl.class), @@ -1572,11 +1585,10 @@ @MetaValue(value = "MergeNode", targetEntity = MergeNodeImpl.class), @MetaValue(value = "NullExpression", targetEntity = NullExpressionImpl.class), @MetaValue(value = "OperatorExpression", targetEntity = OperatorExpressionImpl.class), - @MetaValue(value = "PathSelectExpression", targetEntity = PathSelectExpressionImpl.class), - @MetaValue(value = "PathStepExpression", targetEntity = PathStepExpressionImpl.class), @MetaValue(value = "PerformActionUsage", targetEntity = PerformActionUsageImpl.class), @MetaValue(value = "RequirementUsage", targetEntity = RequirementUsageImpl.class), @MetaValue(value = "SatisfyRequirementUsage", targetEntity = SatisfyRequirementUsageImpl.class), + @MetaValue(value = "SelectExpression", targetEntity = SelectExpressionImpl.class), @MetaValue(value = "SendActionUsage", targetEntity = SendActionUsageImpl.class), @MetaValue(value = "StateUsage", targetEntity = StateUsageImpl.class), @MetaValue(value = "Step", targetEntity = StepImpl.class), @@ -1682,6 +1694,7 @@ @MetaValue(value = "CaseUsage", targetEntity = CaseUsageImpl.class), @MetaValue(value = "Class", targetEntity = ClassImpl.class), @MetaValue(value = "Classifier", targetEntity = ClassifierImpl.class), + @MetaValue(value = "CollectExpression", targetEntity = CollectExpressionImpl.class), @MetaValue(value = "ConcernDefinition", targetEntity = ConcernDefinitionImpl.class), @MetaValue(value = "ConcernUsage", targetEntity = ConcernUsageImpl.class), @MetaValue(value = "ConjugatedPortDefinition", targetEntity = ConjugatedPortDefinitionImpl.class), @@ -1701,6 +1714,7 @@ @MetaValue(value = "ExhibitStateUsage", targetEntity = ExhibitStateUsageImpl.class), @MetaValue(value = "Expression", targetEntity = ExpressionImpl.class), @MetaValue(value = "Feature", targetEntity = FeatureImpl.class), + @MetaValue(value = "FeatureChainExpression", targetEntity = FeatureChainExpressionImpl.class), @MetaValue(value = "FeatureReferenceExpression", targetEntity = FeatureReferenceExpressionImpl.class), @MetaValue(value = "FlowConnectionUsage", targetEntity = FlowConnectionUsageImpl.class), @MetaValue(value = "ForLoopActionUsage", targetEntity = ForLoopActionUsageImpl.class), @@ -1738,8 +1752,6 @@ @MetaValue(value = "OperatorExpression", targetEntity = OperatorExpressionImpl.class), @MetaValue(value = "PartDefinition", targetEntity = PartDefinitionImpl.class), @MetaValue(value = "PartUsage", targetEntity = PartUsageImpl.class), - @MetaValue(value = "PathSelectExpression", targetEntity = PathSelectExpressionImpl.class), - @MetaValue(value = "PathStepExpression", targetEntity = PathStepExpressionImpl.class), @MetaValue(value = "PerformActionUsage", targetEntity = PerformActionUsageImpl.class), @MetaValue(value = "PortDefinition", targetEntity = PortDefinitionImpl.class), @MetaValue(value = "PortUsage", targetEntity = PortUsageImpl.class), @@ -1751,6 +1763,7 @@ @MetaValue(value = "RequirementDefinition", targetEntity = RequirementDefinitionImpl.class), @MetaValue(value = "RequirementUsage", targetEntity = RequirementUsageImpl.class), @MetaValue(value = "SatisfyRequirementUsage", targetEntity = SatisfyRequirementUsageImpl.class), + @MetaValue(value = "SelectExpression", targetEntity = SelectExpressionImpl.class), @MetaValue(value = "SendActionUsage", targetEntity = SendActionUsageImpl.class), @MetaValue(value = "SourceEnd", targetEntity = SourceEndImpl.class), @MetaValue(value = "StateDefinition", targetEntity = StateDefinitionImpl.class), diff --git a/conf/META-INF/persistence.xml b/conf/META-INF/persistence.xml index 3707bd7b..22ce3884 100644 --- a/conf/META-INF/persistence.xml +++ b/conf/META-INF/persistence.xml @@ -51,6 +51,7 @@ org.omg.sysml.metamodel.impl.CaseUsageImpl org.omg.sysml.metamodel.impl.ClassifierImpl org.omg.sysml.metamodel.impl.ClassImpl + org.omg.sysml.metamodel.impl.CollectExpressionImpl org.omg.sysml.metamodel.impl.CommentImpl org.omg.sysml.metamodel.impl.ConcernDefinitionImpl org.omg.sysml.metamodel.impl.ConcernUsageImpl @@ -79,6 +80,7 @@ org.omg.sysml.metamodel.impl.ExhibitStateUsageImpl org.omg.sysml.metamodel.impl.ExposeImpl org.omg.sysml.metamodel.impl.ExpressionImpl + org.omg.sysml.metamodel.impl.FeatureChainExpressionImpl org.omg.sysml.metamodel.impl.FeatureChainingImpl org.omg.sysml.metamodel.impl.FeatureImpl org.omg.sysml.metamodel.impl.FeatureMembershipImpl @@ -129,8 +131,6 @@ org.omg.sysml.metamodel.impl.ParameterMembershipImpl org.omg.sysml.metamodel.impl.PartDefinitionImpl org.omg.sysml.metamodel.impl.PartUsageImpl - org.omg.sysml.metamodel.impl.PathSelectExpressionImpl - org.omg.sysml.metamodel.impl.PathStepExpressionImpl org.omg.sysml.metamodel.impl.PerformActionUsageImpl org.omg.sysml.metamodel.impl.PortConjugationImpl org.omg.sysml.metamodel.impl.PortDefinitionImpl @@ -149,6 +149,7 @@ org.omg.sysml.metamodel.impl.ResultExpressionMembershipImpl org.omg.sysml.metamodel.impl.ReturnParameterMembershipImpl org.omg.sysml.metamodel.impl.SatisfyRequirementUsageImpl + org.omg.sysml.metamodel.impl.SelectExpressionImpl org.omg.sysml.metamodel.impl.SendActionUsageImpl org.omg.sysml.metamodel.impl.SourceEndImpl org.omg.sysml.metamodel.impl.SpecializationImpl @@ -202,7 +203,7 @@ - + diff --git a/generated/org/omg/sysml/metamodel/impl/CollectExpressionImpl_.java b/generated/org/omg/sysml/metamodel/impl/CollectExpressionImpl_.java new file mode 100644 index 00000000..bef2a946 --- /dev/null +++ b/generated/org/omg/sysml/metamodel/impl/CollectExpressionImpl_.java @@ -0,0 +1,152 @@ +package org.omg.sysml.metamodel.impl; + +import java.util.UUID; +import javax.annotation.processing.Generated; +import javax.persistence.metamodel.CollectionAttribute; +import javax.persistence.metamodel.ListAttribute; +import javax.persistence.metamodel.SingularAttribute; +import javax.persistence.metamodel.StaticMetamodel; +import org.omg.sysml.metamodel.Annotation; +import org.omg.sysml.metamodel.Behavior; +import org.omg.sysml.metamodel.Comment; +import org.omg.sysml.metamodel.Disjoining; +import org.omg.sysml.metamodel.Documentation; +import org.omg.sysml.metamodel.Element; +import org.omg.sysml.metamodel.Expression; +import org.omg.sysml.metamodel.Feature; +import org.omg.sysml.metamodel.FeatureChaining; +import org.omg.sysml.metamodel.FeatureDirectionKind; +import org.omg.sysml.metamodel.FeatureMembership; +import org.omg.sysml.metamodel.FeatureTyping; +import org.omg.sysml.metamodel.Import; +import org.omg.sysml.metamodel.Membership; +import org.omg.sysml.metamodel.Redefinition; +import org.omg.sysml.metamodel.Relationship; +import org.omg.sysml.metamodel.Specialization; +import org.omg.sysml.metamodel.Subsetting; +import org.omg.sysml.metamodel.TextualRepresentation; +import org.omg.sysml.metamodel.Type; +import org.omg.sysml.metamodel.TypeFeaturing; + +@Generated(value = "org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor") +@StaticMetamodel(CollectExpressionImpl.class) +public abstract class CollectExpressionImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + + public static volatile ListAttribute argument; + public static volatile ListAttribute chainingFeature; + public static volatile ListAttribute ownedTypeFeaturing; + public static volatile SingularAttribute isConjugated; + public static volatile SingularAttribute isUnique; + public static volatile CollectionAttribute ownedSubsetting; + public static volatile ListAttribute type; + public static volatile SingularAttribute operator; + public static volatile ListAttribute output; + public static volatile SingularAttribute isSufficient; + public static volatile ListAttribute documentationComment; + public static volatile SingularAttribute isOrdered; + public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute identifier; + public static volatile SingularAttribute isDerived; + public static volatile ListAttribute ownedAnnotation; + public static volatile ListAttribute ownedFeature; + public static volatile SingularAttribute qualifiedName; + public static volatile ListAttribute documentation; + public static volatile ListAttribute endFeature; + public static volatile ListAttribute directedFeature; + public static volatile SingularAttribute isEnd; + public static volatile ListAttribute featuringType; + public static volatile ListAttribute input; + public static volatile SingularAttribute isComposite; + public static volatile SingularAttribute name; + public static volatile ListAttribute ownedMember; + public static volatile ListAttribute ownedMembership; + public static volatile CollectionAttribute ownedDisjoining; + public static volatile ListAttribute membership; + public static volatile SingularAttribute isPortion; + public static volatile SingularAttribute isNonunique; + public static volatile ListAttribute ownedFeatureChaining; + public static volatile SingularAttribute isReadOnly; + public static volatile ListAttribute ownedTyping; + public static volatile ListAttribute feature; + public static volatile ListAttribute inheritedMembership; + public static volatile ListAttribute parameter; + public static volatile ListAttribute member; + public static volatile ListAttribute ownedEndFeature; + public static volatile ListAttribute ownedFeatureMembership; + public static volatile ListAttribute inheritedFeature; + public static volatile ListAttribute behavior; + public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute direction; + public static volatile ListAttribute importedMembership; + public static volatile ListAttribute ownedElement; + public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute ownedRelationship; + public static volatile ListAttribute featureMembership; + public static volatile ListAttribute ownedImport; + public static volatile SingularAttribute isAbstract; + public static volatile CollectionAttribute ownedTextualRepresentation; + public static volatile SingularAttribute humanId; + public static volatile ListAttribute aliasId; + public static volatile ListAttribute ownedSpecialization; + public static volatile ListAttribute operand; + + public static final String ARGUMENT = "argument"; + public static final String CHAINING_FEATURE = "chainingFeature"; + public static final String OWNED_TYPE_FEATURING = "ownedTypeFeaturing"; + public static final String IS_CONJUGATED = "isConjugated"; + public static final String IS_UNIQUE = "isUnique"; + public static final String OWNED_SUBSETTING = "ownedSubsetting"; + public static final String TYPE = "type"; + public static final String OPERATOR = "operator"; + public static final String OUTPUT = "output"; + public static final String IS_SUFFICIENT = "isSufficient"; + public static final String DOCUMENTATION_COMMENT = "documentationComment"; + public static final String IS_ORDERED = "isOrdered"; + public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String IDENTIFIER = "identifier"; + public static final String IS_DERIVED = "isDerived"; + public static final String OWNED_ANNOTATION = "ownedAnnotation"; + public static final String OWNED_FEATURE = "ownedFeature"; + public static final String QUALIFIED_NAME = "qualifiedName"; + public static final String DOCUMENTATION = "documentation"; + public static final String END_FEATURE = "endFeature"; + public static final String DIRECTED_FEATURE = "directedFeature"; + public static final String IS_END = "isEnd"; + public static final String FEATURING_TYPE = "featuringType"; + public static final String INPUT = "input"; + public static final String IS_COMPOSITE = "isComposite"; + public static final String NAME = "name"; + public static final String OWNED_MEMBER = "ownedMember"; + public static final String OWNED_MEMBERSHIP = "ownedMembership"; + public static final String OWNED_DISJOINING = "ownedDisjoining"; + public static final String MEMBERSHIP = "membership"; + public static final String IS_PORTION = "isPortion"; + public static final String IS_NONUNIQUE = "isNonunique"; + public static final String OWNED_FEATURE_CHAINING = "ownedFeatureChaining"; + public static final String IS_READ_ONLY = "isReadOnly"; + public static final String OWNED_TYPING = "ownedTyping"; + public static final String FEATURE = "feature"; + public static final String INHERITED_MEMBERSHIP = "inheritedMembership"; + public static final String PARAMETER = "parameter"; + public static final String MEMBER = "member"; + public static final String OWNED_END_FEATURE = "ownedEndFeature"; + public static final String OWNED_FEATURE_MEMBERSHIP = "ownedFeatureMembership"; + public static final String INHERITED_FEATURE = "inheritedFeature"; + public static final String BEHAVIOR = "behavior"; + public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String DIRECTION = "direction"; + public static final String IMPORTED_MEMBERSHIP = "importedMembership"; + public static final String OWNED_ELEMENT = "ownedElement"; + public static final String IS_MODEL_LEVEL_EVALUABLE = "isModelLevelEvaluable"; + public static final String OWNED_RELATIONSHIP = "ownedRelationship"; + public static final String FEATURE_MEMBERSHIP = "featureMembership"; + public static final String OWNED_IMPORT = "ownedImport"; + public static final String IS_ABSTRACT = "isAbstract"; + public static final String OWNED_TEXTUAL_REPRESENTATION = "ownedTextualRepresentation"; + public static final String HUMAN_ID = "humanId"; + public static final String ALIAS_ID = "aliasId"; + public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; + public static final String OPERAND = "operand"; + +} + diff --git a/generated/org/omg/sysml/metamodel/impl/FeatureChainExpressionImpl_.java b/generated/org/omg/sysml/metamodel/impl/FeatureChainExpressionImpl_.java new file mode 100644 index 00000000..f547e13f --- /dev/null +++ b/generated/org/omg/sysml/metamodel/impl/FeatureChainExpressionImpl_.java @@ -0,0 +1,152 @@ +package org.omg.sysml.metamodel.impl; + +import java.util.UUID; +import javax.annotation.processing.Generated; +import javax.persistence.metamodel.CollectionAttribute; +import javax.persistence.metamodel.ListAttribute; +import javax.persistence.metamodel.SingularAttribute; +import javax.persistence.metamodel.StaticMetamodel; +import org.omg.sysml.metamodel.Annotation; +import org.omg.sysml.metamodel.Behavior; +import org.omg.sysml.metamodel.Comment; +import org.omg.sysml.metamodel.Disjoining; +import org.omg.sysml.metamodel.Documentation; +import org.omg.sysml.metamodel.Element; +import org.omg.sysml.metamodel.Expression; +import org.omg.sysml.metamodel.Feature; +import org.omg.sysml.metamodel.FeatureChaining; +import org.omg.sysml.metamodel.FeatureDirectionKind; +import org.omg.sysml.metamodel.FeatureMembership; +import org.omg.sysml.metamodel.FeatureTyping; +import org.omg.sysml.metamodel.Import; +import org.omg.sysml.metamodel.Membership; +import org.omg.sysml.metamodel.Redefinition; +import org.omg.sysml.metamodel.Relationship; +import org.omg.sysml.metamodel.Specialization; +import org.omg.sysml.metamodel.Subsetting; +import org.omg.sysml.metamodel.TextualRepresentation; +import org.omg.sysml.metamodel.Type; +import org.omg.sysml.metamodel.TypeFeaturing; + +@Generated(value = "org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor") +@StaticMetamodel(FeatureChainExpressionImpl.class) +public abstract class FeatureChainExpressionImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + + public static volatile ListAttribute argument; + public static volatile ListAttribute chainingFeature; + public static volatile ListAttribute ownedTypeFeaturing; + public static volatile SingularAttribute isConjugated; + public static volatile SingularAttribute isUnique; + public static volatile CollectionAttribute ownedSubsetting; + public static volatile ListAttribute type; + public static volatile SingularAttribute operator; + public static volatile ListAttribute output; + public static volatile SingularAttribute isSufficient; + public static volatile ListAttribute documentationComment; + public static volatile SingularAttribute isOrdered; + public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute identifier; + public static volatile SingularAttribute isDerived; + public static volatile ListAttribute ownedAnnotation; + public static volatile ListAttribute ownedFeature; + public static volatile SingularAttribute qualifiedName; + public static volatile ListAttribute documentation; + public static volatile ListAttribute endFeature; + public static volatile ListAttribute directedFeature; + public static volatile SingularAttribute isEnd; + public static volatile ListAttribute featuringType; + public static volatile ListAttribute input; + public static volatile SingularAttribute isComposite; + public static volatile SingularAttribute name; + public static volatile ListAttribute ownedMember; + public static volatile ListAttribute ownedMembership; + public static volatile CollectionAttribute ownedDisjoining; + public static volatile ListAttribute membership; + public static volatile SingularAttribute isPortion; + public static volatile SingularAttribute isNonunique; + public static volatile ListAttribute ownedFeatureChaining; + public static volatile SingularAttribute isReadOnly; + public static volatile ListAttribute ownedTyping; + public static volatile ListAttribute feature; + public static volatile ListAttribute inheritedMembership; + public static volatile ListAttribute parameter; + public static volatile ListAttribute member; + public static volatile ListAttribute ownedEndFeature; + public static volatile ListAttribute ownedFeatureMembership; + public static volatile ListAttribute inheritedFeature; + public static volatile ListAttribute behavior; + public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute direction; + public static volatile ListAttribute importedMembership; + public static volatile ListAttribute ownedElement; + public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute ownedRelationship; + public static volatile ListAttribute featureMembership; + public static volatile ListAttribute ownedImport; + public static volatile SingularAttribute isAbstract; + public static volatile CollectionAttribute ownedTextualRepresentation; + public static volatile SingularAttribute humanId; + public static volatile ListAttribute aliasId; + public static volatile ListAttribute ownedSpecialization; + public static volatile ListAttribute operand; + + public static final String ARGUMENT = "argument"; + public static final String CHAINING_FEATURE = "chainingFeature"; + public static final String OWNED_TYPE_FEATURING = "ownedTypeFeaturing"; + public static final String IS_CONJUGATED = "isConjugated"; + public static final String IS_UNIQUE = "isUnique"; + public static final String OWNED_SUBSETTING = "ownedSubsetting"; + public static final String TYPE = "type"; + public static final String OPERATOR = "operator"; + public static final String OUTPUT = "output"; + public static final String IS_SUFFICIENT = "isSufficient"; + public static final String DOCUMENTATION_COMMENT = "documentationComment"; + public static final String IS_ORDERED = "isOrdered"; + public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String IDENTIFIER = "identifier"; + public static final String IS_DERIVED = "isDerived"; + public static final String OWNED_ANNOTATION = "ownedAnnotation"; + public static final String OWNED_FEATURE = "ownedFeature"; + public static final String QUALIFIED_NAME = "qualifiedName"; + public static final String DOCUMENTATION = "documentation"; + public static final String END_FEATURE = "endFeature"; + public static final String DIRECTED_FEATURE = "directedFeature"; + public static final String IS_END = "isEnd"; + public static final String FEATURING_TYPE = "featuringType"; + public static final String INPUT = "input"; + public static final String IS_COMPOSITE = "isComposite"; + public static final String NAME = "name"; + public static final String OWNED_MEMBER = "ownedMember"; + public static final String OWNED_MEMBERSHIP = "ownedMembership"; + public static final String OWNED_DISJOINING = "ownedDisjoining"; + public static final String MEMBERSHIP = "membership"; + public static final String IS_PORTION = "isPortion"; + public static final String IS_NONUNIQUE = "isNonunique"; + public static final String OWNED_FEATURE_CHAINING = "ownedFeatureChaining"; + public static final String IS_READ_ONLY = "isReadOnly"; + public static final String OWNED_TYPING = "ownedTyping"; + public static final String FEATURE = "feature"; + public static final String INHERITED_MEMBERSHIP = "inheritedMembership"; + public static final String PARAMETER = "parameter"; + public static final String MEMBER = "member"; + public static final String OWNED_END_FEATURE = "ownedEndFeature"; + public static final String OWNED_FEATURE_MEMBERSHIP = "ownedFeatureMembership"; + public static final String INHERITED_FEATURE = "inheritedFeature"; + public static final String BEHAVIOR = "behavior"; + public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String DIRECTION = "direction"; + public static final String IMPORTED_MEMBERSHIP = "importedMembership"; + public static final String OWNED_ELEMENT = "ownedElement"; + public static final String IS_MODEL_LEVEL_EVALUABLE = "isModelLevelEvaluable"; + public static final String OWNED_RELATIONSHIP = "ownedRelationship"; + public static final String FEATURE_MEMBERSHIP = "featureMembership"; + public static final String OWNED_IMPORT = "ownedImport"; + public static final String IS_ABSTRACT = "isAbstract"; + public static final String OWNED_TEXTUAL_REPRESENTATION = "ownedTextualRepresentation"; + public static final String HUMAN_ID = "humanId"; + public static final String ALIAS_ID = "aliasId"; + public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; + public static final String OPERAND = "operand"; + +} + diff --git a/generated/org/omg/sysml/metamodel/impl/PathSelectExpressionImpl_.java b/generated/org/omg/sysml/metamodel/impl/PathSelectExpressionImpl_.java deleted file mode 100644 index 06d7fb09..00000000 --- a/generated/org/omg/sysml/metamodel/impl/PathSelectExpressionImpl_.java +++ /dev/null @@ -1,152 +0,0 @@ -package org.omg.sysml.metamodel.impl; - -import java.util.UUID; -import javax.annotation.processing.Generated; -import javax.persistence.metamodel.CollectionAttribute; -import javax.persistence.metamodel.ListAttribute; -import javax.persistence.metamodel.SingularAttribute; -import javax.persistence.metamodel.StaticMetamodel; -import org.omg.sysml.metamodel.Annotation; -import org.omg.sysml.metamodel.Behavior; -import org.omg.sysml.metamodel.Comment; -import org.omg.sysml.metamodel.Disjoining; -import org.omg.sysml.metamodel.Documentation; -import org.omg.sysml.metamodel.Element; -import org.omg.sysml.metamodel.Expression; -import org.omg.sysml.metamodel.Feature; -import org.omg.sysml.metamodel.FeatureChaining; -import org.omg.sysml.metamodel.FeatureDirectionKind; -import org.omg.sysml.metamodel.FeatureMembership; -import org.omg.sysml.metamodel.FeatureTyping; -import org.omg.sysml.metamodel.Import; -import org.omg.sysml.metamodel.Membership; -import org.omg.sysml.metamodel.Redefinition; -import org.omg.sysml.metamodel.Relationship; -import org.omg.sysml.metamodel.Specialization; -import org.omg.sysml.metamodel.Subsetting; -import org.omg.sysml.metamodel.TextualRepresentation; -import org.omg.sysml.metamodel.Type; -import org.omg.sysml.metamodel.TypeFeaturing; - -@Generated(value = "org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor") -@StaticMetamodel(PathSelectExpressionImpl.class) -public abstract class PathSelectExpressionImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { - - public static volatile ListAttribute argument; - public static volatile ListAttribute chainingFeature; - public static volatile ListAttribute ownedTypeFeaturing; - public static volatile SingularAttribute isConjugated; - public static volatile SingularAttribute isUnique; - public static volatile CollectionAttribute ownedSubsetting; - public static volatile ListAttribute type; - public static volatile SingularAttribute operator; - public static volatile ListAttribute output; - public static volatile SingularAttribute isSufficient; - public static volatile ListAttribute documentationComment; - public static volatile SingularAttribute isOrdered; - public static volatile CollectionAttribute ownedRedefinition; - public static volatile SingularAttribute identifier; - public static volatile SingularAttribute isDerived; - public static volatile ListAttribute ownedAnnotation; - public static volatile ListAttribute ownedFeature; - public static volatile SingularAttribute qualifiedName; - public static volatile ListAttribute documentation; - public static volatile ListAttribute endFeature; - public static volatile ListAttribute directedFeature; - public static volatile SingularAttribute isEnd; - public static volatile ListAttribute featuringType; - public static volatile ListAttribute input; - public static volatile SingularAttribute isComposite; - public static volatile SingularAttribute name; - public static volatile ListAttribute ownedMember; - public static volatile ListAttribute ownedMembership; - public static volatile CollectionAttribute ownedDisjoining; - public static volatile ListAttribute membership; - public static volatile SingularAttribute isPortion; - public static volatile SingularAttribute isNonunique; - public static volatile ListAttribute ownedFeatureChaining; - public static volatile SingularAttribute isReadOnly; - public static volatile ListAttribute ownedTyping; - public static volatile ListAttribute feature; - public static volatile ListAttribute inheritedMembership; - public static volatile ListAttribute parameter; - public static volatile ListAttribute member; - public static volatile ListAttribute ownedEndFeature; - public static volatile ListAttribute ownedFeatureMembership; - public static volatile ListAttribute inheritedFeature; - public static volatile ListAttribute behavior; - public static volatile SingularAttribute effectiveName; - public static volatile SingularAttribute direction; - public static volatile ListAttribute importedMembership; - public static volatile ListAttribute ownedElement; - public static volatile SingularAttribute isModelLevelEvaluable; - public static volatile ListAttribute ownedRelationship; - public static volatile ListAttribute featureMembership; - public static volatile ListAttribute ownedImport; - public static volatile SingularAttribute isAbstract; - public static volatile CollectionAttribute ownedTextualRepresentation; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; - public static volatile ListAttribute ownedSpecialization; - public static volatile ListAttribute operand; - - public static final String ARGUMENT = "argument"; - public static final String CHAINING_FEATURE = "chainingFeature"; - public static final String OWNED_TYPE_FEATURING = "ownedTypeFeaturing"; - public static final String IS_CONJUGATED = "isConjugated"; - public static final String IS_UNIQUE = "isUnique"; - public static final String OWNED_SUBSETTING = "ownedSubsetting"; - public static final String TYPE = "type"; - public static final String OPERATOR = "operator"; - public static final String OUTPUT = "output"; - public static final String IS_SUFFICIENT = "isSufficient"; - public static final String DOCUMENTATION_COMMENT = "documentationComment"; - public static final String IS_ORDERED = "isOrdered"; - public static final String OWNED_REDEFINITION = "ownedRedefinition"; - public static final String IDENTIFIER = "identifier"; - public static final String IS_DERIVED = "isDerived"; - public static final String OWNED_ANNOTATION = "ownedAnnotation"; - public static final String OWNED_FEATURE = "ownedFeature"; - public static final String QUALIFIED_NAME = "qualifiedName"; - public static final String DOCUMENTATION = "documentation"; - public static final String END_FEATURE = "endFeature"; - public static final String DIRECTED_FEATURE = "directedFeature"; - public static final String IS_END = "isEnd"; - public static final String FEATURING_TYPE = "featuringType"; - public static final String INPUT = "input"; - public static final String IS_COMPOSITE = "isComposite"; - public static final String NAME = "name"; - public static final String OWNED_MEMBER = "ownedMember"; - public static final String OWNED_MEMBERSHIP = "ownedMembership"; - public static final String OWNED_DISJOINING = "ownedDisjoining"; - public static final String MEMBERSHIP = "membership"; - public static final String IS_PORTION = "isPortion"; - public static final String IS_NONUNIQUE = "isNonunique"; - public static final String OWNED_FEATURE_CHAINING = "ownedFeatureChaining"; - public static final String IS_READ_ONLY = "isReadOnly"; - public static final String OWNED_TYPING = "ownedTyping"; - public static final String FEATURE = "feature"; - public static final String INHERITED_MEMBERSHIP = "inheritedMembership"; - public static final String PARAMETER = "parameter"; - public static final String MEMBER = "member"; - public static final String OWNED_END_FEATURE = "ownedEndFeature"; - public static final String OWNED_FEATURE_MEMBERSHIP = "ownedFeatureMembership"; - public static final String INHERITED_FEATURE = "inheritedFeature"; - public static final String BEHAVIOR = "behavior"; - public static final String EFFECTIVE_NAME = "effectiveName"; - public static final String DIRECTION = "direction"; - public static final String IMPORTED_MEMBERSHIP = "importedMembership"; - public static final String OWNED_ELEMENT = "ownedElement"; - public static final String IS_MODEL_LEVEL_EVALUABLE = "isModelLevelEvaluable"; - public static final String OWNED_RELATIONSHIP = "ownedRelationship"; - public static final String FEATURE_MEMBERSHIP = "featureMembership"; - public static final String OWNED_IMPORT = "ownedImport"; - public static final String IS_ABSTRACT = "isAbstract"; - public static final String OWNED_TEXTUAL_REPRESENTATION = "ownedTextualRepresentation"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; - public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; - public static final String OPERAND = "operand"; - -} - diff --git a/generated/org/omg/sysml/metamodel/impl/PathStepExpressionImpl_.java b/generated/org/omg/sysml/metamodel/impl/PathStepExpressionImpl_.java deleted file mode 100644 index 2246a795..00000000 --- a/generated/org/omg/sysml/metamodel/impl/PathStepExpressionImpl_.java +++ /dev/null @@ -1,152 +0,0 @@ -package org.omg.sysml.metamodel.impl; - -import java.util.UUID; -import javax.annotation.processing.Generated; -import javax.persistence.metamodel.CollectionAttribute; -import javax.persistence.metamodel.ListAttribute; -import javax.persistence.metamodel.SingularAttribute; -import javax.persistence.metamodel.StaticMetamodel; -import org.omg.sysml.metamodel.Annotation; -import org.omg.sysml.metamodel.Behavior; -import org.omg.sysml.metamodel.Comment; -import org.omg.sysml.metamodel.Disjoining; -import org.omg.sysml.metamodel.Documentation; -import org.omg.sysml.metamodel.Element; -import org.omg.sysml.metamodel.Expression; -import org.omg.sysml.metamodel.Feature; -import org.omg.sysml.metamodel.FeatureChaining; -import org.omg.sysml.metamodel.FeatureDirectionKind; -import org.omg.sysml.metamodel.FeatureMembership; -import org.omg.sysml.metamodel.FeatureTyping; -import org.omg.sysml.metamodel.Import; -import org.omg.sysml.metamodel.Membership; -import org.omg.sysml.metamodel.Redefinition; -import org.omg.sysml.metamodel.Relationship; -import org.omg.sysml.metamodel.Specialization; -import org.omg.sysml.metamodel.Subsetting; -import org.omg.sysml.metamodel.TextualRepresentation; -import org.omg.sysml.metamodel.Type; -import org.omg.sysml.metamodel.TypeFeaturing; - -@Generated(value = "org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor") -@StaticMetamodel(PathStepExpressionImpl.class) -public abstract class PathStepExpressionImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { - - public static volatile ListAttribute argument; - public static volatile ListAttribute chainingFeature; - public static volatile ListAttribute ownedTypeFeaturing; - public static volatile SingularAttribute isConjugated; - public static volatile SingularAttribute isUnique; - public static volatile CollectionAttribute ownedSubsetting; - public static volatile ListAttribute type; - public static volatile SingularAttribute operator; - public static volatile ListAttribute output; - public static volatile SingularAttribute isSufficient; - public static volatile ListAttribute documentationComment; - public static volatile SingularAttribute isOrdered; - public static volatile CollectionAttribute ownedRedefinition; - public static volatile SingularAttribute identifier; - public static volatile SingularAttribute isDerived; - public static volatile ListAttribute ownedAnnotation; - public static volatile ListAttribute ownedFeature; - public static volatile SingularAttribute qualifiedName; - public static volatile ListAttribute documentation; - public static volatile ListAttribute endFeature; - public static volatile ListAttribute directedFeature; - public static volatile SingularAttribute isEnd; - public static volatile ListAttribute featuringType; - public static volatile ListAttribute input; - public static volatile SingularAttribute isComposite; - public static volatile SingularAttribute name; - public static volatile ListAttribute ownedMember; - public static volatile ListAttribute ownedMembership; - public static volatile CollectionAttribute ownedDisjoining; - public static volatile ListAttribute membership; - public static volatile SingularAttribute isPortion; - public static volatile SingularAttribute isNonunique; - public static volatile ListAttribute ownedFeatureChaining; - public static volatile SingularAttribute isReadOnly; - public static volatile ListAttribute ownedTyping; - public static volatile ListAttribute feature; - public static volatile ListAttribute inheritedMembership; - public static volatile ListAttribute parameter; - public static volatile ListAttribute member; - public static volatile ListAttribute ownedEndFeature; - public static volatile ListAttribute ownedFeatureMembership; - public static volatile ListAttribute inheritedFeature; - public static volatile ListAttribute behavior; - public static volatile SingularAttribute effectiveName; - public static volatile SingularAttribute direction; - public static volatile ListAttribute importedMembership; - public static volatile ListAttribute ownedElement; - public static volatile SingularAttribute isModelLevelEvaluable; - public static volatile ListAttribute ownedRelationship; - public static volatile ListAttribute featureMembership; - public static volatile ListAttribute ownedImport; - public static volatile SingularAttribute isAbstract; - public static volatile CollectionAttribute ownedTextualRepresentation; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; - public static volatile ListAttribute ownedSpecialization; - public static volatile ListAttribute operand; - - public static final String ARGUMENT = "argument"; - public static final String CHAINING_FEATURE = "chainingFeature"; - public static final String OWNED_TYPE_FEATURING = "ownedTypeFeaturing"; - public static final String IS_CONJUGATED = "isConjugated"; - public static final String IS_UNIQUE = "isUnique"; - public static final String OWNED_SUBSETTING = "ownedSubsetting"; - public static final String TYPE = "type"; - public static final String OPERATOR = "operator"; - public static final String OUTPUT = "output"; - public static final String IS_SUFFICIENT = "isSufficient"; - public static final String DOCUMENTATION_COMMENT = "documentationComment"; - public static final String IS_ORDERED = "isOrdered"; - public static final String OWNED_REDEFINITION = "ownedRedefinition"; - public static final String IDENTIFIER = "identifier"; - public static final String IS_DERIVED = "isDerived"; - public static final String OWNED_ANNOTATION = "ownedAnnotation"; - public static final String OWNED_FEATURE = "ownedFeature"; - public static final String QUALIFIED_NAME = "qualifiedName"; - public static final String DOCUMENTATION = "documentation"; - public static final String END_FEATURE = "endFeature"; - public static final String DIRECTED_FEATURE = "directedFeature"; - public static final String IS_END = "isEnd"; - public static final String FEATURING_TYPE = "featuringType"; - public static final String INPUT = "input"; - public static final String IS_COMPOSITE = "isComposite"; - public static final String NAME = "name"; - public static final String OWNED_MEMBER = "ownedMember"; - public static final String OWNED_MEMBERSHIP = "ownedMembership"; - public static final String OWNED_DISJOINING = "ownedDisjoining"; - public static final String MEMBERSHIP = "membership"; - public static final String IS_PORTION = "isPortion"; - public static final String IS_NONUNIQUE = "isNonunique"; - public static final String OWNED_FEATURE_CHAINING = "ownedFeatureChaining"; - public static final String IS_READ_ONLY = "isReadOnly"; - public static final String OWNED_TYPING = "ownedTyping"; - public static final String FEATURE = "feature"; - public static final String INHERITED_MEMBERSHIP = "inheritedMembership"; - public static final String PARAMETER = "parameter"; - public static final String MEMBER = "member"; - public static final String OWNED_END_FEATURE = "ownedEndFeature"; - public static final String OWNED_FEATURE_MEMBERSHIP = "ownedFeatureMembership"; - public static final String INHERITED_FEATURE = "inheritedFeature"; - public static final String BEHAVIOR = "behavior"; - public static final String EFFECTIVE_NAME = "effectiveName"; - public static final String DIRECTION = "direction"; - public static final String IMPORTED_MEMBERSHIP = "importedMembership"; - public static final String OWNED_ELEMENT = "ownedElement"; - public static final String IS_MODEL_LEVEL_EVALUABLE = "isModelLevelEvaluable"; - public static final String OWNED_RELATIONSHIP = "ownedRelationship"; - public static final String FEATURE_MEMBERSHIP = "featureMembership"; - public static final String OWNED_IMPORT = "ownedImport"; - public static final String IS_ABSTRACT = "isAbstract"; - public static final String OWNED_TEXTUAL_REPRESENTATION = "ownedTextualRepresentation"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; - public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; - public static final String OPERAND = "operand"; - -} - diff --git a/generated/org/omg/sysml/metamodel/impl/SelectExpressionImpl_.java b/generated/org/omg/sysml/metamodel/impl/SelectExpressionImpl_.java new file mode 100644 index 00000000..4dbe99cd --- /dev/null +++ b/generated/org/omg/sysml/metamodel/impl/SelectExpressionImpl_.java @@ -0,0 +1,152 @@ +package org.omg.sysml.metamodel.impl; + +import java.util.UUID; +import javax.annotation.processing.Generated; +import javax.persistence.metamodel.CollectionAttribute; +import javax.persistence.metamodel.ListAttribute; +import javax.persistence.metamodel.SingularAttribute; +import javax.persistence.metamodel.StaticMetamodel; +import org.omg.sysml.metamodel.Annotation; +import org.omg.sysml.metamodel.Behavior; +import org.omg.sysml.metamodel.Comment; +import org.omg.sysml.metamodel.Disjoining; +import org.omg.sysml.metamodel.Documentation; +import org.omg.sysml.metamodel.Element; +import org.omg.sysml.metamodel.Expression; +import org.omg.sysml.metamodel.Feature; +import org.omg.sysml.metamodel.FeatureChaining; +import org.omg.sysml.metamodel.FeatureDirectionKind; +import org.omg.sysml.metamodel.FeatureMembership; +import org.omg.sysml.metamodel.FeatureTyping; +import org.omg.sysml.metamodel.Import; +import org.omg.sysml.metamodel.Membership; +import org.omg.sysml.metamodel.Redefinition; +import org.omg.sysml.metamodel.Relationship; +import org.omg.sysml.metamodel.Specialization; +import org.omg.sysml.metamodel.Subsetting; +import org.omg.sysml.metamodel.TextualRepresentation; +import org.omg.sysml.metamodel.Type; +import org.omg.sysml.metamodel.TypeFeaturing; + +@Generated(value = "org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor") +@StaticMetamodel(SelectExpressionImpl.class) +public abstract class SelectExpressionImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + + public static volatile ListAttribute argument; + public static volatile ListAttribute chainingFeature; + public static volatile ListAttribute ownedTypeFeaturing; + public static volatile SingularAttribute isConjugated; + public static volatile SingularAttribute isUnique; + public static volatile CollectionAttribute ownedSubsetting; + public static volatile ListAttribute type; + public static volatile SingularAttribute operator; + public static volatile ListAttribute output; + public static volatile SingularAttribute isSufficient; + public static volatile ListAttribute documentationComment; + public static volatile SingularAttribute isOrdered; + public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute identifier; + public static volatile SingularAttribute isDerived; + public static volatile ListAttribute ownedAnnotation; + public static volatile ListAttribute ownedFeature; + public static volatile SingularAttribute qualifiedName; + public static volatile ListAttribute documentation; + public static volatile ListAttribute endFeature; + public static volatile ListAttribute directedFeature; + public static volatile SingularAttribute isEnd; + public static volatile ListAttribute featuringType; + public static volatile ListAttribute input; + public static volatile SingularAttribute isComposite; + public static volatile SingularAttribute name; + public static volatile ListAttribute ownedMember; + public static volatile ListAttribute ownedMembership; + public static volatile CollectionAttribute ownedDisjoining; + public static volatile ListAttribute membership; + public static volatile SingularAttribute isPortion; + public static volatile SingularAttribute isNonunique; + public static volatile ListAttribute ownedFeatureChaining; + public static volatile SingularAttribute isReadOnly; + public static volatile ListAttribute ownedTyping; + public static volatile ListAttribute feature; + public static volatile ListAttribute inheritedMembership; + public static volatile ListAttribute parameter; + public static volatile ListAttribute member; + public static volatile ListAttribute ownedEndFeature; + public static volatile ListAttribute ownedFeatureMembership; + public static volatile ListAttribute inheritedFeature; + public static volatile ListAttribute behavior; + public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute direction; + public static volatile ListAttribute importedMembership; + public static volatile ListAttribute ownedElement; + public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute ownedRelationship; + public static volatile ListAttribute featureMembership; + public static volatile ListAttribute ownedImport; + public static volatile SingularAttribute isAbstract; + public static volatile CollectionAttribute ownedTextualRepresentation; + public static volatile SingularAttribute humanId; + public static volatile ListAttribute aliasId; + public static volatile ListAttribute ownedSpecialization; + public static volatile ListAttribute operand; + + public static final String ARGUMENT = "argument"; + public static final String CHAINING_FEATURE = "chainingFeature"; + public static final String OWNED_TYPE_FEATURING = "ownedTypeFeaturing"; + public static final String IS_CONJUGATED = "isConjugated"; + public static final String IS_UNIQUE = "isUnique"; + public static final String OWNED_SUBSETTING = "ownedSubsetting"; + public static final String TYPE = "type"; + public static final String OPERATOR = "operator"; + public static final String OUTPUT = "output"; + public static final String IS_SUFFICIENT = "isSufficient"; + public static final String DOCUMENTATION_COMMENT = "documentationComment"; + public static final String IS_ORDERED = "isOrdered"; + public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String IDENTIFIER = "identifier"; + public static final String IS_DERIVED = "isDerived"; + public static final String OWNED_ANNOTATION = "ownedAnnotation"; + public static final String OWNED_FEATURE = "ownedFeature"; + public static final String QUALIFIED_NAME = "qualifiedName"; + public static final String DOCUMENTATION = "documentation"; + public static final String END_FEATURE = "endFeature"; + public static final String DIRECTED_FEATURE = "directedFeature"; + public static final String IS_END = "isEnd"; + public static final String FEATURING_TYPE = "featuringType"; + public static final String INPUT = "input"; + public static final String IS_COMPOSITE = "isComposite"; + public static final String NAME = "name"; + public static final String OWNED_MEMBER = "ownedMember"; + public static final String OWNED_MEMBERSHIP = "ownedMembership"; + public static final String OWNED_DISJOINING = "ownedDisjoining"; + public static final String MEMBERSHIP = "membership"; + public static final String IS_PORTION = "isPortion"; + public static final String IS_NONUNIQUE = "isNonunique"; + public static final String OWNED_FEATURE_CHAINING = "ownedFeatureChaining"; + public static final String IS_READ_ONLY = "isReadOnly"; + public static final String OWNED_TYPING = "ownedTyping"; + public static final String FEATURE = "feature"; + public static final String INHERITED_MEMBERSHIP = "inheritedMembership"; + public static final String PARAMETER = "parameter"; + public static final String MEMBER = "member"; + public static final String OWNED_END_FEATURE = "ownedEndFeature"; + public static final String OWNED_FEATURE_MEMBERSHIP = "ownedFeatureMembership"; + public static final String INHERITED_FEATURE = "inheritedFeature"; + public static final String BEHAVIOR = "behavior"; + public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String DIRECTION = "direction"; + public static final String IMPORTED_MEMBERSHIP = "importedMembership"; + public static final String OWNED_ELEMENT = "ownedElement"; + public static final String IS_MODEL_LEVEL_EVALUABLE = "isModelLevelEvaluable"; + public static final String OWNED_RELATIONSHIP = "ownedRelationship"; + public static final String FEATURE_MEMBERSHIP = "featureMembership"; + public static final String OWNED_IMPORT = "ownedImport"; + public static final String IS_ABSTRACT = "isAbstract"; + public static final String OWNED_TEXTUAL_REPRESENTATION = "ownedTextualRepresentation"; + public static final String HUMAN_ID = "humanId"; + public static final String ALIAS_ID = "aliasId"; + public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; + public static final String OPERAND = "operand"; + +} + diff --git a/public/jsonld/metamodel/PathSelectExpression.jsonld b/public/jsonld/metamodel/CollectExpression.jsonld similarity index 100% rename from public/jsonld/metamodel/PathSelectExpression.jsonld rename to public/jsonld/metamodel/CollectExpression.jsonld diff --git a/public/jsonld/metamodel/FeatureChainExpression.jsonld b/public/jsonld/metamodel/FeatureChainExpression.jsonld new file mode 100644 index 00000000..6182139c --- /dev/null +++ b/public/jsonld/metamodel/FeatureChainExpression.jsonld @@ -0,0 +1,79 @@ +{ + "@context": { + "@vocab": "http://omg.org/ns/sysml/v2/metamodel#", + "sysml": "http://omg.org/ns/sysml/v2/metamodel#", + "dcterms": "http://purl.org/dc/terms/", + "xsd": "http://www.w3.org/2001/XMLSchema#", + + "aliasId": {"@type": "xsd:string"}, + "argument": {"@type": "@id"}, + "behavior": {"@type": "@id"}, + "chainingFeature": {"@type": "@id"}, + "directedFeature": {"@type": "@id"}, + "direction": {"@type": "@vocab"}, + "documentation": {"@type": "@id"}, + "documentationComment": {"@type": "@id"}, + "effectiveName": {"@type": "xsd:string"}, + "endFeature": {"@type": "@id"}, + "endOwningType": {"@type": "@id"}, + "feature": {"@type": "@id"}, + "featureMembership": {"@type": "@id"}, + "featuringType": {"@type": "@id"}, + "function": {"@type": "@id"}, + "humanId": {"@type": "xsd:string"}, + "identifier": {"@type": "dcterms:identifier"}, + "importedMembership": {"@type": "@id"}, + "inheritedFeature": {"@type": "@id"}, + "inheritedMembership": {"@type": "@id"}, + "input": {"@type": "@id"}, + "isAbstract": {"@type": "xsd:boolean"}, + "isComposite": {"@type": "xsd:boolean"}, + "isConjugated": {"@type": "xsd:boolean"}, + "isDerived": {"@type": "xsd:boolean"}, + "isEnd": {"@type": "xsd:boolean"}, + "isModelLevelEvaluable": {"@type": "xsd:boolean"}, + "isNonunique": {"@type": "xsd:boolean"}, + "isOrdered": {"@type": "xsd:boolean"}, + "isPortion": {"@type": "xsd:boolean"}, + "isReadOnly": {"@type": "xsd:boolean"}, + "isSufficient": {"@type": "xsd:boolean"}, + "isUnique": {"@type": "xsd:boolean"}, + "member": {"@type": "@id"}, + "membership": {"@type": "@id"}, + "multiplicity": {"@type": "@id"}, + "name": {"@type": "xsd:string"}, + "operand": {"@type": "@id"}, + "operator": {"@type": "xsd:string"}, + "output": {"@type": "@id"}, + "ownedAnnotation": {"@type": "@id"}, + "ownedConjugator": {"@type": "@id"}, + "ownedDisjoining": {"@type": "@id"}, + "ownedElement": {"@type": "@id"}, + "ownedEndFeature": {"@type": "@id"}, + "ownedFeature": {"@type": "@id"}, + "ownedFeatureChaining": {"@type": "@id"}, + "ownedFeatureMembership": {"@type": "@id"}, + "ownedImport": {"@type": "@id"}, + "ownedMember": {"@type": "@id"}, + "ownedMembership": {"@type": "@id"}, + "ownedRedefinition": {"@type": "@id"}, + "ownedRelationship": {"@type": "@id"}, + "ownedSpecialization": {"@type": "@id"}, + "ownedSubsetting": {"@type": "@id"}, + "ownedTextualRepresentation": {"@type": "@id"}, + "ownedTypeFeaturing": {"@type": "@id"}, + "ownedTyping": {"@type": "@id"}, + "owner": {"@type": "@id"}, + "owningFeatureMembership": {"@type": "@id"}, + "owningMembership": {"@type": "@id"}, + "owningNamespace": {"@type": "@id"}, + "owningRelationship": {"@type": "@id"}, + "owningType": {"@type": "@id"}, + "parameter": {"@type": "@id"}, + "qualifiedName": {"@type": "xsd:string"}, + "result": {"@type": "@id"}, + "targetFeature": {"@type": "@id"}, + "type": {"@type": "@id"} + + } +} \ No newline at end of file diff --git a/public/jsonld/metamodel/PathStepExpression.jsonld b/public/jsonld/metamodel/SelectExpression.jsonld similarity index 100% rename from public/jsonld/metamodel/PathStepExpression.jsonld rename to public/jsonld/metamodel/SelectExpression.jsonld From 3c6847767b77179de046c8ddf6220109157ab57c Mon Sep 17 00:00:00 2001 From: Ivan Gomes Date: Sun, 27 Feb 2022 20:26:27 -0500 Subject: [PATCH 3/3] Update version number to 2022-02-m1 --- build.sbt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.sbt b/build.sbt index c2b5c46d..56da8328 100644 --- a/build.sbt +++ b/build.sbt @@ -1,7 +1,7 @@ name := """SysML-v2-API-Services""" organization := "org.omg" -version := "2022-01-p1" +version := "2022-02-m1" javacOptions ++= Seq("-source", "11", "-target", "11", "-Xlint")